I've been writing PHP for 13+ years and leading teams for a good part of that. If you asked me what the most important habit on a team is, I'd say code review without thinking. Nothing ships until a second pair of eyes has read it.

Today Amazon released a product where nobody did that.

What AWS released

On November 11, 2026, AWS launched AWS Emulator, a local stand-in for its cloud. You run it on your laptop, a dev server or in CI, point your code at it, and your code thinks it's talking to real AWS. No account needed, and AWS says it has "no additional service fee".

For non-developers: it's a flight simulator. You practise takeoffs without paying for fuel, and if you crash, nobody gets hurt.

GeekWire reports it covers 200+ services. The code is on GitHub.

The headline part is how it was built. In Amazon's own write-up, Senior Principal Engineer Matthew Goldberg says thousands of autonomous agents wrote every line, and: "Our team hasn't written or reviewed any of the code."

So what did the humans do?

That's the more interesting question. According to Amazon:

  • The first version came out of a weekend experiment. An agent produced "a passable first version" of one service (SQS) in about 15 minutes.
  • Agents write fidelity tests from AWS's public API definitions, and each test is verified against real AWS before it's accepted. They now have "tens of thousands of fidelity tests".
  • Every change goes through a merge gate: build, review, security and fidelity. The review step is done by agents too.
  • Humans designed the workflow and the guardrails, and decided when to release.

A guest post on All Things Distributed sums up the philosophy: "Software quality in the AI era depends on the guardrails that engineers design around agents."

So "nobody reviewed it" isn't the same as "nobody checked it". It's reviewed by tests and by other agents, against the real thing.

My first reaction: mild panic

I'll admit it. My stomach dropped a bit. I've seen what slips through even with careful human review. I've shipped worse bugs than I'd like to admit, and those were reviewed by people who knew the codebase.

Tests only catch what someone thought to test. That's always been the weak spot.

My second reaction: wait, I already do this

Then I thought about my own stack. I've never read the source of Symfony's router line by line, or my database engine, or the PHP interpreter. I trust them because they have huge test suites and a track record.

AWS's bet is that a strong enough test suite, checked against reality, can replace line-by-line reading. For an emulator that bet is unusually safe, because there's a perfect reference: the real AWS. Every behaviour can be compared against the original. Most of our products don't have that luxury. There's no "real version" of your startup's checkout flow to diff against.

Where I land

For a testing tool, I'm fine with this. If the emulator is wrong, a test fails on someone's laptop and they go and check real AWS. The blast radius is small.

For code that moves money, handles health data or deletes things, I still want a human who understands the business reading it. Not because humans are smarter, but because someone has to be accountable for the parts the tests never imagined.

AWS also lists honest limits: it doesn't evaluate IAM policies the way AWS does, it acts as a single account, unimplemented operations return HTTP 501, and fidelity varies by service. That's a sign the guardrails are real, not marketing.

What this means for your job

The skill that's getting more valuable isn't typing code. It's writing down what "correct" means so precisely that a machine can check it. Specs, tests, acceptance rules, the boring stuff many of us skipped.

If you're a developer, the practical move this week is to look at one feature you own and ask: if an agent rewrote this tomorrow, would my tests catch it if it got something wrong? If the answer is "probably not", that's your new to-do list, with or without AI.

And if you're a founder, it's worth asking your team the same question.

I'm still a bit sad about code review. It's where I've learned the most from colleagues. Maybe agents will learn from each other the same way. I'd pay to watch that retro.

Would you run code in production that no human has reviewed, if the tests were strong enough? Why or why not?