跪拜 Guibai
← All articles
Backend · Java · Architecture

Architects Who Stop Writing Code Lose the Ability to Judge a System

By SamDeepThinking ·
Read original on juejin.cn ↗ Google Translate ↗ Alt translation

The gap between design authority and implementation knowledge widens silently as engineers move into architecture roles. When the person with veto power over technical decisions no longer knows the codebase, teams absorb the cost: proposals get derailed by suggestions that are directionally correct but practically impossible to execute within the given constraints.

Summary

A common failure mode in technical reviews: an architect interrupts with a textbook best practice — a message center, a service mesh, an event bus — without knowing whether the system has one, what it would cost to build, or whether the business timeline can absorb it. The suggestion isn't wrong in principle; it's wrong because it substitutes industry patterns for knowledge of the actual code.

Architecture design depends on accurate judgment of the current state: where coupling is severe, what historical baggage exists, which changes are frequent. Documentation rarely captures this. The information lives in the code, and the only way to access it is to keep reading and writing code. Once an architect stops, the remaining inputs are industry practices and past experience — both valid references, but neither a substitute for knowing what the system looks like today.

The pattern surfaces most often in review meetings because that's the last place a non-coding architect still touches system details. A proposal triggers a memory of a pattern, and the suggestion comes out without the calibration that hands-on work provides.

Takeaways
An architect who hasn't written or read code recently cannot accurately judge what the system has, what it lacks, or what a change would cost.
Industry best practices are choices made for someone else's team size, business model, codebase, and history — they don't transfer automatically.
Past experience corresponds to a system that no longer exists; code, business, and team have all changed since then.
Suggestions that surface during reviews often come from architects whose only remaining contact with system details is the review meeting itself.
Code reviews on core modules, reading recent diffs, prototyping new components, and participating in incident response all keep architectural judgment grounded.
Conclusions

Review meetings function as a trap: they are the venue where architectural authority is exercised, but for someone who no longer codes, they are also the only remaining window into the system — a window too narrow to support sound decisions.

The damage isn't that the suggestion is wrong. It's that the suggestion arrives without cost awareness, so the team must either absorb the distraction of explaining why it doesn't fit or accept scope creep they can't afford.

Documentation is systematically insufficient for architecture work. The real state of coupling, shared tables, and tangled logic is only visible in code, which means architecture without code access is architecture by hearsay.

Source: juejin.cn ↗ Google Translate ↗ Backup ↗