There’s a quiet shift happening inside engineering teams right now. Some people feel it every day. Others sense it but can’t quite put a name to it yet. It’s the moment where writing code stops being the slow part of software development.
This shift isn’t about hype. It isn’t about magic. And it definitely isn’t about pressing a button and letting an AI write your entire product.
It’s about something much more real:
Engineers are getting 10x faster with AI in the loop.
Not in the “Twitter thread productivity guru” way. Not in the “fake screenshots of 1,000-line diffs generated in 3 seconds” way.
It’s quieter. More grounded. More practical.And it’s starting to change how we build software.
In his article “The New Calculus of AI-based Coding,” Joe Magerramov explains this shift beautifully. He describes a world where AI isn’t replacing engineers but reshaping the cost structure of engineering itself. A world where tasks that were once painful suddenly feel easy. A world where the real bottleneck becomes something entirely new.
This article takes those ideas and builds on them with observations from real tools like Amazon Q, Kiro, and Amazon Bedrock, and the reality of what’s happening inside engineering teams right now.
Let’s take it piece by piece and look at what’s really changing.
The Productivity Jump Everyone’s Quietly Talking About
Across teams, this is the pattern:
- Engineers use AI to generate code.
- Engineers review every line.
- Work gets done much faster.
- Quality often improves because the team can explore more ideas.
- The part that slows things down isn’t coding anymore.
It sounds simple, but it’s not. There’s nuance here, especially with the concerns people bring up.
When people first hear about “10x productivity,” they usually push back. The concerns are fair:
- Isn’t AI going to create bugs I won’t see?
- What if I don’t understand the code it writes?
- What if the AI gives me something that only “looks right” but is actually wrong?
These aren’t fake worries. Everyone in engineering has thought them at least once. And to be honest, these were my worries too.
But something shifted over the past month.
A Personal Observation: What I Saw Using Amazon Q and Kiro
Over the past month, I’ve noticed something interesting while working with Amazon Q and Kiro. The teams that benefit most from AI coding aren’t treating it as a replacement for engineering.
They treat AI like a teammate.
They let the AI generate code, test stubs, docstrings, helper functions, or refactors. But they still review everything. They step through logic. They catch edge cases. They ask the AI to fix mistakes, but they stay in control.
- This is why the results end up being better, not worse.
- There’s more exploration.
- More options to compare.
- More iterations in the same amount of time.
AI isn’t reducing understanding. It’s reducing busywork.
What engineers are doing now is directing the work rather than manually grinding through everything themselves. And that leads to the big conceptual change.
The Shift From “Vibe Coding” to “Agentic Coding”
Before AI tools matured, a lot of coding was called “vibe coding.” You know how it goes:
- You vaguely know what you want to build.
- You open your IDE.
- You start typing.
- You improvise.
- You debug.
- You patch things.
- You keep going until it kinda, sorta works.
It’s like cooking without a recipe and hoping your instincts are right.
AI doesn’t let you vibe your way through code like that. It forces something different, a style we can call agentic coding.
Agentic coding means:
- You describe the problem clearly.
- The AI generates an attempt.
- You check it carefully.
- You correct it.
- You iterate together.
It’s a conversation. A back-and-forth loop. A partnership. You’re not giving up control. You’re giving up repetitive effort.
The best engineers using AI today aren’t the ones who type the least. They’re the ones who think the most clearly. AI coding makes thinking the main job again.
So What Happens When Coding Gets 10x Faster?
If AI makes writing code 10x faster (and in many cases it does), the obvious assumption is that engineering will become 10x more productive overall.
But that’s not what actually happens.
Why?
Because coding wasn’t the slowest part of engineering.
This is the twist that people often miss. Even before AI, coding was never the real bottleneck. The slowest part was:
- Talking to other engineers
- Syncing on requirements
- Clarifying edge cases
- Aligning on design
- Getting reviews
- Handling handoffs
- Managing dependencies
- Coordinating across teams
AI speeds up the parts that were already kind of fast. The coordination parts? Those stay the same. And that causes something surprising.
The Coordination Bottleneck: A Kitchen or an F1 Pit Crew
When teams become faster at producing code, the limiting factor becomes communication.
An analogy that fits well here is a restaurant kitchen. If the chefs suddenly start preparing food 10x faster, what happens? It’s not the cooking that breaks. It’s:
- The communication
- The timing
- The plating
- The coordination
- The flow
The kitchen can’t run faster unless the whole system runs faster.
Or think about a Formula 1 pit crew. These teams perform under extreme speed. But the limiting factor isn’t the individual mechanic turning a bolt. It’s how everyone synchronizes, perfectly!.
This is exactly what’s happening in engineering.
When AI boosts coding speed:
- Standups suddenly feel too slow.
- Design docs matter more than ever.
- Clear requirements save hours.
- Reviews become the long pole.
- Debates and misalignment hurt more.
- Every “quick question” becomes expensive.
AI doesn’t actually eliminate the human elements. It amplifies them. This is the new calculus of engineering.
The Hidden Benefit: Practices That Were Slow Become Easy
Here’s the part that doesn’t get enough attention:
AI makes previously “expensive” engineering practices cheap.
Think about all the things we used to want to do:
- Full end-to-end local test setups
- Comprehensive test suites
- More fake dependencies and mock environments
- Extremely thorough documentation
- Multiple design explorations
- Cleaner, more modular codebases
- Real-time consistency checks
- More frequent refactoring
We didn’t do these things because they were too slow or painful. They were “nice to have.” With AI, they’re suddenly… normal.
Tools like Amazon Bedrock and Q can:
- Generate test files
- Maintain them
- Update mocks
- Rewrite large sections to fit new architectures
- Refactor without breaking style
- Add missing edge cases
- Suggest improvements
- Detect patterns humans overlook
- Keep everything in sync
This might be the biggest opportunity in engineering since version control. AI doesn’t just speed up the old way of doing things. It makes better ways doable.
Why This Matters for Teams
Think about the impact if:
- Tests become complete by default
- Documentation stops being an afterthought
- Refactoring becomes painless
- Onboarding gets easier
- Teams align faster
- The cost of mistakes drops
- The codebase stays clean
- Tech debt stops piling up
Teams don’t just become faster. They become calmer.
- There’s less firefighting.
- Less manual cleanup.
- Less “tribal knowledge.”
- Less stress.
- Less overtime.
And an engineering culture built on clarity instead of chaos.
This is why the shift to AI-assisted work isn’t about replacing anyone. It’s about letting teams operate like they always wanted to.
What This Means for Engineering Managers
Managers are starting to notice different problems:
- Engineers deliver code fast but wait for alignment.
- Reviews pile up.
- Roadmaps feel too slow.
- Cross-team blockers hurt more.
- Quality gaps show up when collaboration is weak.
AI increases output, but humans still drive direction. So managers have to evolve too.
The teams that thrive will focus on:
- Clear problem statements
- Lightweight specs
- High bandwidth communication
- Shorter feedback loops
- Better review practices
- Regular architecture health checks
- Strong shared ownership
- Rapid iteration cycles
The future manager isn’t a coordinator of tasks. They’re a coordinator of collaboration.
What This Means for Engineers
For engineers, AI shifts the skill set. Typing fast matters less. Understanding deeply matters more.
The engineer who thrives in this new world is someone who:
- Thinks clearly
- Can articulate intent
- Understands architecture
- Catches subtle issues
- Explains trade-offs
- Breaks down problems
- Reviews intelligently
- Designs for maintainability
AI makes the technical hands-on part faster, but the judgment part becomes more important.
AI coding doesn’t remove engineering skill. It raises the bar for what skill looks like.
Where Amazon Q, Kiro, and Bedrock Fit In
These tools aren’t just assistants. They’re becoming parts of the workflow.
Amazon Q handles reasoning in code, generating prototypes, test suites, and refactors.
Kiro helps with end-to-end development flows and improves team-wide consistency.
Amazon Bedrock provides the foundation models that keep this entire system adaptive, scalable, and aligned with enterprise standards.
These tools don’t eliminate engineering work. They upgrade it.
They make the job less about typing and more about designing, reviewing, and improving whole systems.
The Real Change: Engineering Feels Fun Again
This might sound cheesy, but it’s true.
When AI handles the boring parts, engineers get to:
- Explore more ideas
- Focus on architecture
- Iterate quickly
- Try things without fear
- Learn faster
- Spend more time in flow
- Build things they’re proud of
AI-assisted coding is bringing back something we lost:
the joy of building.
- The joy of saying, “What if we tried this?”
- The joy of tinkering.
- The joy of instant feedback.
- The joy of shipping fast without burning out.
That’s the part no one talks about enough.
Where This Is All Going
We’re heading to a place where:
- Code generation is the norm
- Reviews happen in real-time with AI
- Local testing is automatic and complete
- Documentation writes itself
- Refactors become background tasks
- CI/CD pipelines get smarter
- Design becomes the core skill
- Teams move faster than their org charts
- Collaboration becomes the primary bottleneck
- Engineering practices evolve into something entirely new
The future isn’t “AI writes the code.”
The future is:
Engineers and AI build together.
And teams that learn to coordinate well will outperform everyone else.
The Big Question Worth Asking
If AI becomes a standard part of every engineer’s workflow…
What new engineering practices will become standard too?
That’s the question that matters.
- Maybe it’s fully automated testing.
- Maybe it’s continuous refactoring.
- Maybe it’s AI-augmented design reviews.
- Maybe it’s new development metrics.
- Maybe it’s a new style of documentation.
- Maybe it’s something none of us can see yet.
But one thing is clear:
We’re at the start of a new era in software development.
And the teams that embrace it thoughtfully, with curiosity, honesty, and a willingness to rethink old habits, will build the next generation of great products.
THE NUCLEAR GEEKS 