Frontend · Backend · AI Programming

Vibe Coding Didn't Kill the Programmer — It Just Changed the Job Description

By 谭sir · Jul 16, 2026

Read original on juejin.cn ↗ Google Translate ↗ Alt translation

When AI handles the typing, a developer's value moves entirely upstream — into requirement clarity, risk judgment, and system design. Teams that don't adapt their review, testing, and documentation practices will ship broken software faster, not better software.

Summary

A developer who has barely written code by hand in a year lays out the workflow that replaced it: clarify requirements with AI, let it generate the implementation, then rigorously review, test, and verify every change. The bottleneck shifted from typing syntax to thinking clearly about what to build and whether the result is safe to ship.

That shift rewrites team practices. Interactive demos replace static PRDs, project rules and UI specs get written down so AI doesn't drift, PRs stay scoped to one thing, and tests are driven by acceptance criteria — not by the implementation AI just produced. High-risk code like payments still demands human review of idempotency, transactions, retries, and compensation.

Two career paths emerge. Product engineers own the full delivery cycle from problem to feedback, using AI to cover gaps in their stack. Technical experts stay deep on databases, compilers, distributed systems, and security — domains where generating code is the easy part and long-term analysis is the real work.

Takeaways

— AI now handles most code generation for routine features, but a human still reviews every change for correctness, security, and side effects.

— Development speed increases don't automatically improve delivery quality; requirement analysis, review, and testing must keep pace.

— A non-developer can build a working demo with AI, but real-world use surfaces data consistency, error recovery, and deployment problems that require engineering skill.

— Project rules — directory structure, naming, error formats, logging — should live in AGENTS.md or docs so AI-generated code stays consistent.

— Each module should carry a README explaining its responsibility and boundaries, updated by AI after each PR merge.

— UI specs must be explicit: button sizes, spacing, modal widths, and state handling prevent AI from producing a patchwork of styles.

— PRs should do one thing; AI's tendency to refactor or reformat unrelated files must be stripped out before review.

— Tests must be generated from requirements and acceptance criteria, not from the implementation code, or they'll silently encode bugs.

— High-risk code — payments, permissions, migrations — needs human review of idempotency, transactions, retries, and compensation logic.

— Programmers must retain the ability to code and debug without AI, or they lose the mental model needed to judge AI's output.

— Learning with AI is faster, but it creates an illusion of competence; real understanding still requires hands-on practice and debugging.

— Product engineers own delivery end-to-end; technical experts stay deep on systems problems where code generation is the trivial part.

Conclusions

The bottleneck in AI-assisted development is no longer code production but decision quality: knowing what to build, what to reject, and what risks a change introduces.

AI's tendency to over-engineer — suggesting message queues for low-volume notification tasks — means engineers must actively push back on complexity, not just accept generated solutions.

The black-box problem for beginners is acute: accepting AI code you can't read turns every bug into a prompt-engineering loop that degrades the codebase over time.

Writing tests from the implementation rather than the spec is a failure mode AI amplifies, because it will faithfully assert the buggy behavior as correct.

Documentation maintenance becomes tractable when AI updates READMEs per PR; the old excuse that docs rot too fast weakens when the cost of updating them approaches zero.

Concepts & terms

Vibe Coding

A development style where the programmer describes intent in natural language and lets AI generate the code, iterating through conversation rather than writing syntax manually.

Product Engineer

An engineer who owns the full delivery cycle — from problem analysis and solution design through implementation, testing, deployment, and user feedback — rather than stopping at code completion.

Idempotency (in payments)

The property that processing the same payment callback multiple times produces the same result as processing it once, preventing double-charging or double-fulfillment when payment platforms retry.

AGENTS.md

A project-level file containing rules and conventions (coding style, directory structure, error formats) that AI coding tools read before generating or modifying code to stay consistent with the project.

Source: juejin.cn ↗ Google Translate ↗ Backup ↗