There's a scene in The Matrix that every engineer of my generation can quote. Neo gets kung fu uploaded into his skull in ten seconds. He opens his eyes and says, "I know kung fu."
Morpheus doesn't clap. He says: "Show me."
Then he beats him up for a while.
I've been thinking about that scene a lot, because two things happened in my orbit within the same month. The stories are composites, as usual, but the shape is real.
The first: a product manager, never wrote production code in her life, shipped a small internal service. Plain English prompts, an agent, a couple of weekends. It's been running for three months. It has health checks, structured logs, a rollback plan and an on-call runbook. Nobody has been paged.
The second: a founder vibe-coded a customer-facing app. It demoed beautifully. It went live on a Friday. By Sunday the database had duplicate orders, an S3 bucket was public, and the API key was in the frontend bundle.
Same tools. Same models. Probably the same prompts, give or take. One of them knew kung fu. The other one had just downloaded it.
The Download
Let's get the uncomfortable fact out of the way first. Syntax is free now.
The thing I spent my twenties memorising, pointer arithmetic, the exact incantation for a Django migration, which Go channel pattern doesn't deadlock, a model writes faster and mostly better than I do. Anyone with a keyboard and a subscription has the download.
So the old gate, "can you write code?", is gone. And a lot of engineers are quietly panicking, because they assumed that gate was the job.
It never was. Typing was the toll booth. The job was everything around it: knowing what to build, where it lives, what it talks to, what happens when that thing is down, and who gets woken up at 3am when it is.
That part didn't get downloaded. That part is still "show me."
Show Me
Here's the thing about models that nobody puts on the landing page: they build exactly what you ask for, and what you don't ask for doesn't exist.
Ask for "an endpoint that creates an order" and you get an endpoint that creates an order. You don't get idempotency, so a retry creates two. You don't get a timeout on the payment call, so one slow provider eats your thread pool. You don't get a migration that can be rolled back. You don't get a metric that tells you any of this is happening.
A demo only has to work once, on the happy path, in front of people who want it to work. Production has to work ten thousand times a day, on every path, in front of users, attackers, flaky networks and a cloud provider having a bad Tuesday.
The gap between those two is almost entirely made of things nobody types into a prompt unless they already know they exist:
- Authentication and authorization (who is this, and are they allowed)
- Input validation and rate limiting
- Timeouts, retries, and idempotency
- Transactions and concurrency
- Secrets that live in a vault, not in the code
- Schema migrations that go forward and back
- Logs, metrics, traces, alerts
- Backups you've actually restored from
- Cost, because an agent will happily build you a beautiful N+1 query that bills by the request
The model knows all of these. It will implement every one of them well, if asked. It just won't volunteer them, the same way a brilliant contractor won't add a fire exit to a building nobody told him people would live in.
Who Actually Ships
So who can produce production-ready code with plain prompts? Not "engineers." Not "non-engineers." The line was never drawn by job title. It's drawn by one question:
Do you know how things fail?
That PM from the first story wasn't a coder. But she'd sat in six years of incident reviews. She knew what a retry storm was because she'd written the customer apology for one. When she prompted, she asked for things the founder didn't know to ask for.
The people I see shipping real, deployable work without writing code by hand tend to look like this:
- The ex-engineer turned manager who hasn't opened an IDE in five years but still thinks in boundaries, contracts and blast radius.
- The SRE or ops person who has never written a feature but has been paged by a thousand of them.
- The architect who stopped coding long ago and now finally has hands again.
- The domain expert who knows the rules cold. A compliance person in healthcare already knows every access must be logged and every record has a retention policy. That's half the architecture.
- The product person who stayed for the postmortems instead of leaving after the launch party.
What they share is not syntax. It's a mental model of how systems behave under stress. Call them non-coders, sure. Don't call them non-engineers. Engineering was always the judgment, not the typing. We just used to bundle the two, because you couldn't get one without the other.
Agent Smith, Everywhere
Now look at what's happening across the industry right now. Not at one company; pick almost any of them. It's the exact opposite of everything above.
It's the trend of the year, and it follows the same script everywhere. The memo comes from the top. Everyone codes now. Product codes. Sales codes. Support codes. The licences are bought, the all-hands slide says "10x", and somebody upstairs has seen a demo.
Then come the layoffs. Never called layoffs, of course. Called efficiency. The senior who knew why the billing service retries three times and not four? Expensive. The SRE who could smell a retry storm from the elevator? Redundant, we have agents now. The people left behind get a short speech: you have the tools, so do their job too.
Then the agents get poured into everything. Jira has an agent that writes tickets. Another agent grooms them. Slack has a bot that summarises a thread a different bot started. Every PR gets an AI review, which pings an AI fixer, which pushes a commit, which triggers the AI review again. Your notifications become a machine-to-machine conversation that politely CCs you.
And the work itself? It stopped being planned. A customer complains on Monday morning, a fix ships Monday afternoon. A bug report becomes a prompt, the prompt becomes a PR, the PR becomes a hotfix on top of last week's hotfix. No RFC. No "does this fit the system?" No "should we even do this?" Just the monster, unleashed, delivering at scale.
It looks like velocity. The burndown chart has never been prettier. But nobody designed the thing you now run. It's sediment: layer after layer of ad hoc patches, each one reasonable on its own, together a system nobody can explain. Nobody is at the wheel, and nobody gets to rest, because the monster doesn't sleep and its output lands on whoever is still around.
And every one of those loops ends in the same place: a human who has to answer. Is this the right fix? Can we ship it? Why is prod on fire? Agents can generate questions forever. They cannot be accountable for a single answer.
Push back, and you'll hear the line. You will always hear the line:
"I gave you tools. Use them."
As if the tools were the scarce thing. As if the bottleneck was ever the typing.
And notice who says it, and who never gets blamed. The AI evangelists. The ones who discovered agents last quarter and now design the SDLC for roles they never held. Writing review policies without ever having been paged. Defining "done" for code they'll never have to maintain. Rolling out processes to teams they've never sat in.
When it goes well, it's their transformation. When it doesn't, it's yours.
Don't use the tools enough? You're a dinosaur, resisting change, a culture problem. Embrace them exactly as you were told and, God forbid, something big slips into production? Now it's "you're the engineer, you should have caught it." The process was theirs. The pager was always yours.
Heads they win. Tails you're out.
Here's what nobody in that boardroom seems to compute. You didn't remove work. You removed the people who knew how things fail, and multiplied the number of things that can. The download got cheaper. The kung fu walked out the door with a severance package.
Somebody, at some point, has to stop the ping-pong. Read the plan. Say no. Own the decision. That somebody is a person with judgment, and you just let half of them go.
Agent Smith can copy himself a million times. It still took one person who understood the system to end it.
Until someone does: welcome to the era of professional suicide by vibing.
The Training Program
Fine, but how? If you have the mental model and no syntax, this is what I've seen work. None of it needs you to read a for-loop.
First, the difference in a single prompt. Here's the download:
Build me an API that lets customers place orders and pay with Stripe.And here's someone who knows kung fu:
Build an order service in FastAPI with PostgreSQL.
- POST /orders requires an Idempotency-Key header; same key returns the same order.
- Payment call to Stripe: 5s timeout, max 2 retries with backoff, never retry a non-idempotent call.
- Order and payment status change in one DB transaction.
- Secrets from environment variables only. Nothing sensitive in logs.
- Alembic migrations, each with a working downgrade.
- Structured JSON logs with a request ID, /health and /ready endpoints, Prometheus metrics for latency and error rate.
- Tests for: duplicate request, Stripe timeout, Stripe 500, DB down.
Ask me before adding any dependency not listed here.Same model. Wildly different outcome. The second prompt contains zero code and roughly fifteen years of scar tissue.
Now the practice around it:
- Write the plan before the prompt. One page: what it does, what it doesn't, what it talks to, what data it owns, who owns it. If you can't write that page, no prompt will save you. (This is the same RFC I argued for in LGTM: Looks Good to Machines. The review moved to the plan. So did the engineering.)
- Put the rules in the repo, not in your head. A conventions file the agent reads every time: stack, folder layout, error handling, logging format, the non-functional checklist above. You write it once. Every prompt after that inherits fifteen years of opinions for free.
- Choose boring technology. Managed Postgres, the cloud's own queue, the deployment pipeline your company already has. Every exotic choice is a decision the model makes for you, and you won't know it made it.
- Make it prove itself. Ask for tests first. Then ask a fresh session to attack the code: "What happens if Redis is down? If the same request arrives twice in 10ms? If the payload is 50MB?" Then actually run it. Then kill the database and watch what it does.
- Observability before features. If you can't see it, you can't own it. Logs, metrics and an alert go in on day one, not after the first incident.
- Ship thin, ship reversible. Behind a feature flag. To ten users, then a hundred. With a rollback you've rehearsed. Production is where Morpheus lives; you want the first sparring session to be short.
- Own the pager. Whoever ships it carries it. Nothing sharpens a prompt like knowing you're the one getting the 3am call.
Don't Fight the Agent in the Red Dress
Some rooms in the dojo are still for black belts only. Knowing how things work includes knowing where your knowledge ends. Call an engineer, a real one, when it touches:
- Authorization. "Can this user see this record?" looks like an if-statement. It's actually the place most breaches live. I've spent a good part of my career (and a PhD) on this one; it's never as simple as it looks.
- Money. Anything that moves it, rounds it, or reconciles it.
- Concurrency at scale. Race conditions don't show up in demos. They show up on Black Friday.
- Data migrations on live systems. The model will write you a perfect migration that locks a 200-million-row table for forty minutes.
- Cryptography. Never roll your own, and never let an agent roll it for you.
- Personal and health data. Regulators don't accept "the model wrote it" as a control.
The skill isn't avoiding these. It's recognising them when they show up disguised as a simple feature.
There Is No Spoon
Now the part that stings.
For engineers: if your value was typing, the PM who sat through six years of postmortems just ate your lunch. That's not a threat. It's an invitation to move up to where the work always was: architecture, contracts, failure modes, mentoring the people who now have hands. A technosaur who knows how systems break is worth more this year than last, not less.
For organisations: stop gating who ships by job title. Gate by understanding, and make understanding visible: a written plan, a conventions file, tests that cover failure, a named owner on the pager. If a non-coder can pass that bar, let them ship. If a senior engineer can't, don't. And if you laid off the people who knew how things fail, no licence, no agent and no all-hands slide will buy that back.
For the non-coders: you don't need to learn Python. You need to learn how things fail. Sit in incident reviews. Read postmortems. Ask your SRE what woke them up last month. That's the kung fu, and unlike Neo's, it doesn't download.
The tools will keep getting better. The demos will keep getting prettier. And production will keep doing what it has always done: standing there, arms crossed, waiting.
"I know kung fu."
Show me.
Member discussion: