I think in September 26 we can agree that models like Sonnet or Grok 4.6 write pretty reasonable code. Adding coding guidelines, architecture references and tests on top, you wouldn't be able to tell if it's written by a human or by a robot.
And if we go a step further and add some agents for testing and documenting on top and call it a harness you don't have to spend anymore time worrying about producing technically bullet proof results.
It's nearly as if you hired a team that does your work for you... just like a manager... But then what do you do?
Well, what does a manager do all day? Ideally, not running after his employees and controlling everything they do.
Instead a (good) manager learnt it's important to not manage people at all, but build (and manage) an environment where people do their best work.
And this is the same thing you need to do in the age of agents.
...but shouldn't I check the code?
Let's really overdo this metaphor: You are hired as the CTO of an e-commerce business, and it's your first week.
You have the first coffee calls with developers and generally it seems like the product is in good shape according to what they tell you.
Still, you want to know how it really looks. So you take a look at some code.
But not at everything, only at specific parts. You don't read a lot of template code. You look at the core business logic - that part of the code that earns the money and that may be relevant to regulations and privacy.
If that doesn't change over time you don't have to look at it again.
That doesn't mean you don't trust. You just want to know what you're dealing with.
And what you see increases or decreases your level of trust.
And that's the same way you work with agents.
You don't just naively trust the code they write. You first look at it and make sure you AND the agent are on the same page about what good looks like.
And over time you watch less and trust more.
But again, not in a naive way, because you have improved the systems and build mechanisms so the code quality stays high.
And then what?
The requirements for your team of agents will evolve.
- You will have a new feature request for which you have to teach your agent new tricks.
- You introduce new dependencies or architectural changes agents need to consider.
- You now have a mobile app that also needs to be touched and verified in the agentic workflow.
- You discover a new capability of AI that you want to use in your workflow.
- You realize an agent always makes the same mistake which causes a hiccup in production.
So you adapt and develop your agents' skills.
And that can mean defining and updating skills, fixing workflows, improving the context you provide by adding access to Figma on top of Jira tickets, and more.
So, you work on the system, rather than micromanaging your agents.