Over the past few weeks, my Git contributions went from roughly 20 a day to over 200. Same hours, same energy, different throughput. The difference is AI agents: we built custom agentic infrastructure, powered by Claude Code, and integrated it deeply into our engineering and internal ops workflows.
Most commentary on this shift gets the implication backwards. When software becomes cheap to build, humans become more valuable, not less. Abundance moves the scarce resource from implementation to judgment, and judgment lives in people. The age of abundance doesn't diminish human contribution: it amplifies it.
This is what we've experienced. Each engineer now manages a team of AI agents, and the vectors all point in the same direction. No politics. No miscommunication. No alignment drift. Just coordinated execution toward shared goals.
The bottleneck was typing speed
A backlog we'd estimated at three months was gone in a week. Not by cutting corners, but by removing the bottleneck of human typing speed from the loop.
The new mandate: every engineer is "promoted" to technical manager of their own team of AI agents. This isn't a metaphor. Our engineers direct work, review outputs, and make judgment calls about tradeoffs. Agents handle the mechanical implementation while humans focus on architecture, code review, and strategic direction.
Speed of iteration compounds everything
Iteration speed sets the rate of progress. Here's how our cycles have compressed:
This matters beyond internal efficiency. Our customers build physical AI systems: autonomous vehicles, robots, embodied agents. Their iteration speed on software determines how fast their systems improve. When we accelerate our velocity, we accelerate theirs.
Alignment becomes solvable
With AI agents, alignment is no longer the hardest problem of scale. Agents execute exactly what they're directed to do; the human's job is ensuring the direction is correct.
A team of 10 humans directing AI agents, all aligned, can outproduce a traditional team of 100 with typical organizational entropy. The math changes when alignment is solvable.
Everyone builds software now
This shift isn't limited to engineers. Our operations team writes software. Our design team writes code. Our sales team builds internal tools. Our product team prototypes features directly. The assumption that "engineering" requires a CS degree is quietly becoming obsolete: if you can articulate what you need and critically evaluate the output, you can build.
This flattens old hierarchies and creates new ones. Shipping working software is no longer scarce. What's scarce is the judgment to know what to build, the taste to know when it's good enough, and the communication skill to direct AI systems effectively. These used to be "soft skills" that supported "hard skills." Now they're the production multipliers.
The new bottleneck is orchestration
For a long time, experience was the bottleneck: senior engineers were valuable because they'd seen patterns before. That bottleneck is loosening. Modern agentic AI has seen more codebases than any human ever will.
What it can't do is decide what matters, which tradeoffs fit your company's constraints, or when "good enough" is actually good enough. The new bottleneck is orchestration ability: breaking down complex goals, communicating clearly, maintaining quality while moving fast, and synthesizing outputs into coherent products.
The same shift is coming for physical AI data
The productivity shift applies to data collection and labeling, the foundation of everything we do at Avala.
Our human labelers, domain experts who understand the nuances of physical AI data, are now augmented by agentic labeling workflows. The AI handles initial passes, suggests annotations, and flags edge cases. The experts focus on quality verification, edge case resolution, and the judgment calls that determine whether a model will work in the real world. A single expert labeler directing AI agents can produce what used to require a team of 10, with higher consistency and faster turnaround.
The pattern is the same as in software: human value shifts from execution to judgment. And judgment is exactly what physical AI requires: someone who can look at a scene and know whether the annotation captures what matters for a robot navigating the real world.
Software moats are compressing
If a small team can rebuild a SaaS product in a week, what is your actual moat? Features that used to represent months of investment can be replicated in days.
For most successful companies, the moat was never really the code. It was network effects, data assets, customer relationships, brand trust, or operational excellence. Software was the delivery mechanism, and the delivery mechanism is commoditizing.
For physical AI companies, this clarifies something important: the moat is the data, not the software. Models can be replicated. Training pipelines can be rebuilt. But high-quality, diverse, accurately labeled data from the real world requires humans in the world, exercising judgment, at scale. That's what we're building at Avala.
Human capital is appreciating
Here's the counterintuitive part: in a world where software is easier to build, human capital becomes more valuable, not less. The constraint shifted from "can we build this?" to "should we build this, what exactly should it do, and how do we know if it's working?" Those are judgment questions: understanding context, weighing tradeoffs, anticipating second-order effects, and deciding under uncertainty.
A thoughtful person without a CS degree can now build software. A domain expert can create tools for their field. The tools of creation are spreading, not concentrating.
This is core to why we built Avala the way we did. Our coworker workforce, people around the world who collect data, exercise judgment, and close the loop on physical AI systems, is exactly the kind of human capital appreciating now. Their uniquely human capabilities (being physically present, exercising contextual judgment, understanding local conditions) are precisely what AI systems need and can't replicate.
You can't build a robot to replace the person teaching robots how to move. You can't train a model to replace the annotator whose judgment determines what the model learns. Physical AI requires humans in the loop not as a temporary limitation, but as a permanent feature of systems that must interact safely with the real world.
How I'd build a team today
If I were building a team from scratch today:
Fewer engineers, more seniority. The marginal value of banging out code quickly has fallen. The marginal value of architecting systems and making sound judgment calls has risen.
Different hiring attributes. Traditional technical interviews test algorithm implementation under pressure. That's no longer the scarce skill. I'd want to know: can you decompose ambiguous problems, communicate requirements precisely, and spot when something is subtly wrong?
Blurred functional boundaries. If everyone can build, your ops person should build the ops tools and your designer should build the prototypes. Handoffs create information loss; direct building capability eliminates them.
Investment in orchestration skills. This is learnable, and the ROI is enormous because it multiplies everything else.
What about engineers who don't want to manage?
"Managing AI agents" isn't people management. No career development conversations, no conflict resolution. It's closer to being a technical architect who can execute rapidly through delegation: decompose problems clearly, communicate precisely, review critically, make fast judgment calls. Some of that is personality. Most is learnable, and you learn it by doing the work, the same way engineers always developed seniority.
The learning loop also compresses. A junior engineer directing AI agents gets exposure to architectural decisions and system-level thinking from day one:
Year 3–4: Feature ownership
Year 5–7: System design exposure
Year 8+: Architectural decisions
Month 4–6: Own small subsystems
Month 7–12: Architectural decisions
Year 2+: Strategic direction
There's a harder truth. Some people genuinely prefer heads-down implementation: the flow state of writing code, the satisfaction of solving puzzles with their own hands. This shift is dislocating for them. Two things still cut in their favor:
Domain expertise becomes the differentiator. An AI agent can write code, but it can't understand why a particular edge case matters in healthcare, why a specific tolerance is critical in aerospace, or why a certain user flow will frustrate actual customers. Deep domain knowledge plus adequate technical skill now beats deep technical skill alone.
New entry points are opening. When shipping software is no longer the bottleneck, the definition of "engineer" expands: the domain expert who directs AI implementation, the designer who ships features, the ops specialist who builds their own tools.
Humans are fundamentally tool makers, but for decades "engineering" was artificially narrow, a priesthood requiring years of specialized training. What we called "engineering" was really problem-solving with a high barrier to entry. The barrier is falling. The definition is reverting to what it always should have been: problem solver.
Let's be honest about the job market
I've heard the critique: this sounds great for founders and senior engineers, but what about people trying to break in now? The criticism is fair. The job market for entry-level software roles is brutal right now. Companies that hired aggressively in 2021–2022 are running leaner, and the traditional entry points, junior developer roles where you learn by doing grunt work, are compressing. The transition period is genuinely painful for many people, and that pain is real.
But the difficulty isn't permanent, and it isn't evenly distributed. The people struggling most are trying to enter through doors that are closing. The opportunity is in recognizing which doors are opening.
If you're a new grad, the honest advice isn't "learn to code better." AI is commoditizing that skill. The advice is: pick a domain you actually care about and go deep. The person who understands healthcare workflows and can direct AI to build solutions will be more valuable than the person who can implement algorithms but doesn't know why they matter. Domain expertise, taste, judgment, and the ability to identify real problems are now directly convertible into working software.
This is why Avala's mission resonates: we're creating paths for people to contribute to building AI systems without traditional credentials. A person in Nairobi who deeply understands how vehicles navigate their local roads can contribute to autonomous driving in ways no engineer in San Francisco can. The age of abundance opens doors. The question is which ones you walk through.
The machines get the machine work
For decades we asked humans to do robotic work: repetitive tasks, mechanical execution, following scripts. We shaped ourselves to fit industrial and digital machinery because we had no choice. AI is absorbing exactly that work.
The dystopian narrative about AI replacing human workers misses this: most "human work" was never a good fit for humans in the first place. What's left after automation is the part that requires being human: judgment calls, creative leaps, ethical considerations, contextual understanding, relationship building. Our engineers aren't stressed about being replaced. They're energized, finally spending time on interesting problems instead of grinding through boilerplate.
The cost of building software is approaching zero. The constraint is no longer "can we afford to build this" but "is this worth building at all." The machines can do the machine work. We get to do the human work.
What we're betting on
The shift is happening now, and it changes the calculus on hiring plans, team structure, skill development, competitive dynamics, and build-vs-buy decisions.
Our bet is simple: code is depreciating and judgment is appreciating. So we're building for judgment. A platform that amplifies human judgment at the scale physical AI requires. A coworker workforce around the world exercising the contextual understanding that keeps AI systems safe and effective. Forward deployed engineers who help other companies restructure workflows, build AI-augmented infrastructure, and keep the connection to physical ground truth.
This is good news for humans. Not "good news but also here's the scary part." Just good news. The skills that are commoditizing are the ones we were never meant to spend our lives on. The ones that matter now, judgment, communication, creativity, and critical evaluation, are the ones that make us human. In the age of abundance, being human matters more than ever. That's what we're betting on.
Emal Alwis is the Founder and CEO of Avala, a 4D world-data platform for Physical AI. If you're navigating the AI-augmented engineering transition and want to compare notes, reach out. Happy to share what's working for us.
