# Token Maxxing Is Over and Here Is What Comes Next

Pepijn Senders, Epilogue | MLOps Community | 35:20
Hosted by Demetrios Brinkmann

Source: https://www.youtube.com/watch?v=b84hZzCZzPM
Channel: MLOps Community, now AAIF Live (https://www.youtube.com/@AAIFLive-x1r). Summarised by MLOps Talks.
Page: https://mlopstalks.com/talks/token-maxxing-is-over-and-here-is-what-comes-next
Published: 2026-10-22
Tags: agents, coding-agents, context-engineering, cost, prompt-engineering

## TL;DR
- Pepijn Senders chose Sonnet because its shorter reasoning loops keep engineers involved in complex banking software.
- AI coding spend needs to be tied to shipped features and business value, rather than token counts or simple productivity multipliers.
- Teams can keep control by refining requirements together, inspecting where humans steer away from model recommendations, and constraining each coding stage's context.

## Summary
Pepijn Senders describes rebuilding a platform in six months with a team of about 50 people and 800,000 lines of code, around 60% written by Sonnet. He chose Sonnet because it stops sooner and asks engineers to steer, which matters when the software contains difficult banking rules. The discussion then turns to AI coding ROI. Pepijn tracks token spend against shipped features, pull requests, lines of code, and the estimated headcount needed without AI. He admits that his earlier attempt to prove ROI at HelloFresh failed because he did not connect faster delivery to the product features that mattered most to the company. He also explains how agents can narrow design choices, why prompts containing words such as "scalable" and "maintainable" change outputs, and how group refinement sessions give engineers, designers, and product managers more control. His team later built a meta harness around Claude Code after finding that most work followed the same refinement, specification, implementation, and verification process.

## Key ideas
### Sonnet keeps engineers involved in difficult software work
[02:37](https://www.youtube.com/watch?v=b84hZzCZzPM&t=157s)
Pepijn Senders calls his approach "Sonnet maxing." He prefers a model that takes fewer thinking steps, reasons less, and stops earlier because developers stay involved. His team used Sonnet to help rebuild an entire platform in six months, producing about 800,000 lines of code, with roughly 60% written by Sonnet. The software includes banking rules that cannot be handed over without close review. Pepijn says a more capable model may build a transaction engine without asking for enough direction, while Sonnet gets stuck earlier and forces the team to steer. The team used AI for suitable tasks while keeping human feedback in the process.

### AI coding ROI has to connect spend with the work the company values
[05:44](https://www.youtube.com/watch?v=b84hZzCZzPM&t=344s)
Pepijn built a dashboard to estimate how many full-time engineers the company gained from AI, using a clear before-and-after point for adoption. He warns that lines of code alone do not explain value. For a new app home screen, he would compare the time and tokens spent with the value of the finished feature. If a screen is only 1% more valuable after $20,000 in token spend, that deserves a conversation. At HelloFresh, he spent six or seven months trying to prove AI's return and admits he failed to tell the story in the company's terms. He should have shown that AI could ship a feature tied to revenue twice as fast.

### Token dashboards start conversations instead of proving a person's worth
[10:41](https://www.youtube.com/watch?v=b84hZzCZzPM&t=641s)
Pepijn's favorite visualization is a scatter chart with token spend on one axis and production on the other. Production can include features shipped, lines shipped, or pull requests merged. A person spending $20,000 while shipping a million lines looks different from someone spending $15,000 and merging one pull request in four weeks, although either comparison needs context. The chart is not an accusation or a final judgment. Someone may be researching, learning a domain, or doing work that the selected measures miss. Pepijn prefers estimating how many engineers would have been needed without AI, rather than claiming a team is 2x or 3x more productive. He also thinks strong performers should be able to justify more spend.

### The codebase test exposes places where the team has lost control
[17:49](https://www.youtube.com/watch?v=b84hZzCZzPM&t=1069s)
Pepijn gives viewers a direct test: open a repository and stop at the first point where they no longer understand what is happening. They should be able to place each function, explain why it exists, and describe its business value. He says that even teams trying to stay in control will find code no one understands. Unknown code can become a production problem, especially in systems that handle customer data. His team measures when humans steer away from the model's proposed direction and reviews sessions after features are built. Those measures are signals for discussion. They do not prove that a team or engineer is performing well or badly by themselves.

### Agent recommendations can quietly narrow the engineering choices
[22:10](https://www.youtube.com/watch?v=b84hZzCZzPM&t=1330s)
Pepijn says agents often present a recommendation as if the available choices are already defined. An engineer who accepts each suggestion without considering alternatives can be guided into a path the team did not deliberately choose. This is especially risky when the engineer is working in an unfamiliar language or wants to finish quickly. Pepijn's team reviews session history, including the code, architecture decisions, and documents, to understand how choices were made. He also argues that model outputs are strongly shaped by the input words. A prompt containing terms such as "React," "scalable," or "maintainable" can push the model toward a different implementation. A more reasoning-heavy model may take an incorrect cue further before asking for help.

### Group refinement sessions make the agent part of a shared discussion
[23:39](https://www.youtube.com/watch?v=b84hZzCZzPM&t=1419s)
Pepijn's team runs refinement sessions with product, UX, and engineering participants. They ingest a feature brief or product requirements document and open the agent live, either during a call or asynchronously. The team discusses the feature as it would have before AI, while the agent finds difficult requirements and places where implementation may be hard in the existing codebase. Working in a group makes it less likely that one engineer will accept every recommendation alone. The product manager can steer the discussion, and the team produces transcripts and other artifacts. Pepijn can later ask for a summary of the session or investigate why a particular decision was made.

### Prompt knowledge lets designers produce code within a controlled repository
[28:01](https://www.youtube.com/watch?v=b84hZzCZzPM&t=1681s)
Pepijn compared one-shot prompts from front-end engineers and designers who were asked to generate a web page. The results looked similar from the outside, but most designers produced a single HTML page with inline JavaScript and CSS, while the engineers produced application projects. Terms such as "React," "scalable," and "maintainable" changed the model's direction. Pepijn's team now gives designers a repository with its context already set. He chose Svelte for that repository because he considers it harder to make mistakes with than React, although he does not describe it as safe as Rust. The coding assistant is also instructed to respond in language suited to designers.

### A meta harness standardizes the repeated stages of AI-assisted coding
[31:42](https://www.youtube.com/watch?v=b84hZzCZzPM&t=1902s)
Pepijn's company harness sits above Claude Code and controls what enters the context window. He describes finding one user's context already filled with about 40,000 tokens because every available skill had been installed, leaving skills to conflict with one another. His team found that 85% of its code followed the same sequence: refinement, specification, implementation, and verification. The harness gives each stage its own context and skills, records what happens, and measures token use for each task stage. A small injected instruction tells Claude Code to touch a file when refinement is complete. A file watcher detects that event, closes the current session, opens the next one, and captures structured data.

## Notable quotes
- Pepijn Senders: "For me like a model that doesn't go for as many thinking steps, doesn't do as much reasoning, stops earlier, keeps the developers more in the loop." (02:58)
- Pepijn Senders: "I don't like to think in like productivity increase like okay, we're 2x 3x better. But I rather think okay, like how many like if we would have to do this with now we're doing this with 20 engineers like before AI we might have needed like 30 or 40 engineers." (13:20)
- Pepijn Senders: "Take your repository, whatever you're working on, open a code base, and stop when you don't understand anymore what's going on." (17:49)
- Pepijn Senders: "We found that 85% of the code was written in the exactly the same way. So, refinement, specification, implementation verification." (33:26)

## Tools & references mentioned
- Pepijn Senders
- Demetrios Brinkmann
- Epilogue
- HelloFresh
- Claude Code
- Sonnet
- Opus
- Fable
- GitHub Copilot
- React
- Svelte
- Rust

## Who should watch
- You are introducing AI coding tools to engineers who need to stay accountable for complex business rules.
- Your finance or leadership team is asking what coding assistants return for their token spend.
- You are designing team workflows around agents and want group review, controlled context, and evidence from coding sessions.

## Related talks

- [Lessons from 25 Trillion Tokens: Scaling AI-Assisted Development at Kilo](https://mlopstalks.com/talks/lessons-from-25-trillion-tokens-scaling-ai-assisted-development-at-kilo) (Scott Breitenother, Kilo, 25:55)
- [The Caveman Prompting Challenge](https://mlopstalks.com/talks/the-caveman-prompting-challenge) (James Barney, MetLife, 44:07)
- [How Agents Changed Vibe Coding Forever](https://mlopstalks.com/talks/how-agents-changed-vibe-coding-forever) (Beyang Liu, Sourcegraph, 49:49)
- [Cutting Costs with Artificial Intelligence](https://mlopstalks.com/talks/cutting-costs-with-artificial-intelligence) (, 12:36)
- [Coding with AI](https://mlopstalks.com/talks/coding-with-ai) (Chip Huyen, Tep Studio, 44:29)