Everyone’s talking about it. The blog posts. The Twitter threads. The LinkedIn thought leaders who haven’t shipped code since 2019. „We’re all AI managers now.“ „The future of engineering is orchestrating agents.“ „I run four Claude Code sessions in parallel and ship ten features before lunch.“
I saw a Reddit post the other day about someone whose friend got into Anthropic. Supposedly they work with agents all day long. They instruct one agent to deliver a feature, and while it’s running, they spin up the next one. And the next one. And the next. Like some kind of AI assembly line where you’re the foreman shouting instructions and collecting pull requests.
And honestly? That sounds incredible. In theory.
In practice, most of you work at companies that can barely get a Confluence page updated, let alone orchestrate four autonomous coding agents in parallel. And I need to talk about why.
The 20% Problem
Here’s something nobody wants to acknowledge when they’re fantasizing about their AI manager future: most engineers don’t actually spend that much time coding.
I’m serious. Think about your average day. You wake up, check Slack, respond to three threads that should have been emails. You hop on a standup that takes 25 minutes because someone is screen-sharing their Jira board. Then you have a „quick sync“ with another team because you need them to update an API endpoint before you can do anything. Then lunch. Then another meeting about the roadmap. Then you finally open your editor at 2 PM, write code for maybe two hours, get pulled into a production incident, and now it’s 5 PM.
My estimation? Most engineers at most companies spend 20 to 30% of their day actually writing code. Some weeks it’s even less. The rest is coordination. Meetings. Tickets. Waiting on other teams. Asking people to do things that should be self-service but aren’t.
So when someone tells me „AI agents will 10x my productivity,“ I think… 10x of what? 10x of the two hours you actually code? Cool. You just saved yourself maybe a day of coding per week. That’s meaningful, sure. But you’re still drowning in the other 70% of your job that no AI agent can touch right now.
The bottleneck was never your typing speed. It was never even your ability to write code. The bottleneck is organizational. It’s process. It’s the fact that deploying a feature requires sign-off from three teams and a change advisory board that meets on Tuesdays.
Your Codebase Isn’t Agent-Ready
Let’s say you do get those two hours of coding time and you want to hand it to an agent. Great. Let me ask you something: what does your codebase look like?
Because here’s the thing people skip over when they talk about agents coding for 30 to 60 minutes autonomously. The agent needs to know what „good“ looks like. It needs patterns. Standards. Structure.
If your codebase is a mix of three different architectural patterns because every tech lead who joined in the last four years brought their own favorite approach, the agent is going to produce garbage. Or worse, it’s going to produce code that works but follows none of your conventions. Spaghetti that passes CI but makes your senior engineers cry.
You need standardized patterns. Hexagonal architecture, domain models, active record, vertical slices, whatever your team uses. Pick one. Document it. Make it so obvious that even a brand-new junior dev (or an AI agent) can look at the existing code and understand exactly how to add a new feature.
This is the part that kills me. Teams that can’t even agree on where to put a new service class think they’re going to hand off feature development to an autonomous agent. Brother, the agent is going to be just as confused as your last three hires were.
The Testing Problem Nobody Talks About
Here’s where it gets really real. For an agent to work autonomously, it needs feedback loops. It needs to know if the code it wrote actually works. And the only way to do that at scale is tests.
Unit tests. Integration tests. End-to-end tests. The agent needs to run them, see green, and have confidence that it didn’t break anything. That’s the whole game. Without tests, you’re just letting a robot commit code into your main branch and hoping for the best. That’s not AI-assisted development. That’s gambling.
And let’s be honest about the state of testing at most companies. Test coverage is spotty at best. Integration tests are flaky. End-to-end tests take 45 minutes to run and fail randomly because someone’s staging environment went down. Half the team doesn’t even run tests locally because „CI will catch it.“
You also need solid linting rules and a build pipeline that catches problems fast. The agent needs to verify its work quickly. If your CI pipeline takes 30 minutes to tell you something is broken, the agent is sitting there doing nothing for 30 minutes. That’s not a productivity revolution. That’s a very expensive idle loop.
The Organizational Problem Is The Real Problem
Now here’s the part nobody wants to hear because it’s not sexy and you can’t solve it with a new tool.
Remember that 70% of your day that isn’t coding? The meetings, the tickets, the cross-team coordination? For agents to actually replace a meaningful chunk of your workload, your organization needs to make all of that stuff self-service and API-driven.
Think about it. You want the agent to create a support ticket? There needs to be an API for that. You want the agent to request access to a database? Self-service portal with an API. You want the agent to coordinate with another team’s service? That team needs well-documented, stable APIs that the agent can actually call.
This means every team in the org needs to be building and maintaining good APIs. Not just for customers. For internal consumers. For agents. The entire organization needs to think about its internal systems as products, not side projects that get attention once a quarter when something breaks.
And that? That’s a multi-year organizational transformation. That’s not a weekend hackathon. That’s not installing Claude Code and hoping for the best.
What „AI Native“ Actually Requires
So let me lay it out. To actually become the „AI manager“ everyone is fantasizing about, your organization needs:
Standardized code patterns that agents can follow. Real test coverage with fast, reliable feedback loops. Linting and build pipelines that catch issues in seconds, not minutes. Self-service internal systems with proper APIs. Cross-team coordination that doesn’t require a human in a Zoom call.
That’s the prerequisite list. And I’d bet money that 90% of engineering organizations haven’t checked off even two of those items.
The people who are actually running four agents in parallel and shipping features all day? They work at places that have already solved these problems. Places like Anthropic, where the entire engineering culture was built around AI-native workflows from day one. They didn’t bolt AI onto a broken process. They built the process around AI.
For the rest of us? The work starts way before you open your terminal and type „claude.“ It starts with fixing your org. Standardizing your patterns. Writing tests. Building self-service systems. Making your internal tools as good as your external products.
The Uncomfortable Truth
The uncomfortable truth is that becoming AI-native is mostly an organizational problem, not a technical one. The AI is ready. Your agents can write code. They can run tests. They can refactor and debug and ship.
But they can’t sit in your planning meeting and argue about priorities. They can’t chase down the platform team to unblock your deployment. They can’t navigate the seventeen-step approval process your VP of engineering put in place after that one production incident in 2023.
Before you can manage AI, you need to manage your process. Before you can orchestrate four agents in parallel, you need to build an environment where even one agent can operate effectively.
So stop dreaming about being an AI foreman and start doing the boring work. Fix your architecture. Write your tests. Build your APIs. Automate your processes. Make your org agent-ready.
Then, and only then, you get to live the dream.
Peace, nerds.