It is high time we stop chasing the mantra of “Token Maxing.”

It is high time we stop chasing the mantra of “Token Maxing.”

There is a subtle trap in trying to squeeze an entire engineering problem into one massive AI-agent session.

The more we do that, the more we risk distancing ourselves from the engineering task we are actually responsible for.

We should almost always start with first principles!

Break the problem down into smaller, manageable sub-tasks that are:
→ Easy to understand
→ Easy to build
→ Easy to review
→ Easy to verify
→ Easy to ship

And we should not shy away from established engineering practices just because we now have AI coding agents.

• Use Jira to break down the work.
• Use Confluence or equivalent documentation to capture decisions.
• Use meaningful GitHub commits as checkpoints.
• Use PRs for human review.
• Use tests and verification to establish confidence.

There is a growing FOMO around AI coding agents:
"If I break this into multiple sessions, I will lose all the context I built with the agent."
And then we convince ourselves that "/compact" will somehow preserve everything that matters.

But context is not the same as understanding.

AI assistants are optimized to be useful, responsive and fast. The trade-offs they make are not only about accuracy. They are also about satisfying the request and moving forward.

This is where your engineering judgment matters the most.

It is incredibly easy to turn on auto-mode and let the agent run.

And then, a while later, you find yourself staring at a large pile of files, changes and abstractions trying to figure out:

"What exactly did it do, and why?"

So we delegate the review to another AI agent.

And slowly, we risk moving the ultimate quality and correctness check downstream, sometimes all the way to the customer.

That is a "dangerous direction for any engineering organisation".

I am NOT saying we shouldn't use auto-mode.

Use it aggressively when the task is well understood and the risk is low.

But there is a certain level of expertise required in understanding the problem you own, its nuances, its failure modes and what "done correctly" actually means.

And that expertise needs to be complemented by enough hands-on exposure to AI agents that you develop a gut feeling for:

• What should I delegate?
• What should I supervise?
• What should I verify myself?
• Where should I stop the agent?

You may not be writing every line of code anymore.

But you are still responsible for the downstream effects of the code you ship.
And that distinction is incredibly important.

#AIEngineering #GenerativeAI #CodingAgents #AIAgents #SoftwareEngineering #AIforDevelopers #EngineeringLeadership #HumanInTheLoop