The versions
- 1.0 — Write everything by hand
- 2.0 — Frameworks, libraries, Stack Overflow
- 3.0 — AI-assisted generation and verification
- You owned every line. Speed was human-limited.
- You assembled. Speed was discovery-limited.
- You orchestrate. Speed is judgment-limited.
Software Engineering 3.0 isn't about AI replacing developers. It's about the bottleneck shifting from writing to deciding.
The keyboard isn't the constraint anymore. Judgment is.
The generation-verification loop
This is the fundamental workflow. Everything else is commentary.
Define the intent
Before generating anything, be precise about what you need. Not "build a login page" but "server action that validates email format, checks against the users table, returns a session token, and handles the three failure modes."
The specificity of the intent determines the quality of the output.
Generate
AI produces code. Multiple approaches if needed. The cost of generation is near zero — use that. Ask for alternatives. Ask for the trade-offs between them.
Verify
This is where the skill lives. Read every line. Check the failure modes. Look for what's missing, not just what's present.
The most dangerous AI output is code that works but is subtly wrong. It passes tests. It handles the happy path. It has a security hole in the error handler, or a race condition under load, or an O(n²) loop that only matters at scale.
Verification isn't "does it run." It's "would I ship this."
Iterate
Feed the verification back. Be specific about what's wrong and why. Each cycle tightens the output.
Commit
Only when verification passes. Quality gates are non-negotiable: lint, type check, tests, security scan.
What changes in practice
You read more than you write
In 3.0, the ratio flips. You spend more time reading, evaluating, and refining than typing. The skill is pattern recognition — spotting the anti-pattern in generated code, catching the edge case the model missed, recognizing when the architecture is wrong even though the implementation is correct.
You need deeper fundamentals to work with AI than without it. When you wrote everything yourself, you caught mistakes in the act of writing. When AI generates, the mistakes arrive fully formed and confident.
Small chunks, always
Never accept a diff larger than 300 lines without breaking it down.
A 500-line AI-generated diff that you approve in one pass isn't collaboration. It's rubber-stamping. Your verification becomes theatrical — you're not actually reading, you're scanning and hoping.
The autonomy slider
Not every task gets the same level of AI involvement.
| Task | Autonomy Level | Why |
|---|---|---|
| Boilerplate, config files | High | Low risk, well-defined output |
| Business logic | Medium | Generate, then verify carefully |
| Security-critical code | Low | Human-driven, AI as reviewer |
| Architecture decisions | Minimal | AI provides options, human decides |
The slider isn't set once. It adjusts per task, per context, per risk level. Calibrated trust, not blind trust.
Quality gates
These aren't optional. They're the architecture of 3.0.
- Lint and format — automated, pre-commit
- Type safety — TypeScript strict, no
any - Test coverage — minimum 80%, meaningful tests
- Security scan — dependency audit, no secrets in code
- Build passes — if it doesn't compile, it doesn't exist
AI-generated code that doesn't pass the gates doesn't ship. The gates are the difference between "AI-assisted development" and "AI-generated chaos."
What doesn't change
- Simplicity beats cleverness
- Delete before you optimize
- Design for failure
- Security is how you build, not what you add
- If it's not in the repo, it doesn't exist
- How code gets written
- The cost of trying alternatives
- The speed of iteration
- The ratio of reading to writing
- The tools (every 6-18 months)
The principles from the Engineering Guidelines hold. Complexity still has gravity. Deletion still beats optimization. Security still isn't a sprint at the end.
What changed is the vehicle, not the destination.
The meta-skill
The best engineers in 3.0 aren't the fastest typists or the best prompt writers. They're the ones who know which problems are worth solving, which solutions are worth building, and which AI output is worth shipping.
That's judgment. And it comes from practice — thousands of cycles through the generation-verification loop, each one refining your intuition for what good looks like.
AI handles the tedious parts. Your job is to handle the important ones.
That's Software Engineering 3.0. Same craft. Different tools. Higher standards.