An instruction to “build a user authentication system” leaves architectural decisions unstated. Where does identity live? Which service checks it? What happens when that service is unavailable? An agent can answer those questions while writing the code, but accepting the implementation also accepts its answers.
Human architectural authority means owning those consequential commitments: module boundaries, data flow, state, the security model, and failure behavior. It is the first pillar of synthesis coding's framework, a practice for combining human judgment with AI-assisted software development. The team can delegate research, design proposals, and implementation while retaining responsibility for the accepted architecture.
Make the decisions visible
Architectural choices become harder to reverse as other components depend on them. A database schema shapes queries and migrations. A service boundary shapes communication and failure handling. A security model determines which components must be trusted. Reviewing one generated component in isolation can miss those consequences.
Consider an authentication change. One request produces a JWT-based flow; another produces a flow using server-side sessions. Either can be part of a deliberate design. The problem is accepting both without deciding how they relate, which component owns authentication, and what the rest of the system should rely on. A locally reasonable implementation can create an unresolved system decision.
The agent needs the business domain, expected workload, existing commitments, and alternatives the team has already rejected. Some of that context may be in the repository; some may be absent or stale. Engineers need to inspect the recommendation against those facts, including facts the agent helps uncover.
Documentation update prepared October 1, 2026: Current agents can retain project information across sessions. Claude Code supports CLAUDE.md instructions and automatic memory files. These give the model context; executable hooks can enforce action constraints. Engineers still own the architectural decisions and review the implementation against them. Claude Code memory documentation.
What the engineer owns
Technology stack and frameworks. A technically suitable stack may create training, staffing, or maintenance obligations. Ask AI to compare alternatives against those obligations, then make the choice with the people who will operate the system. The team needs to understand the consequences of adopting an unfamiliar language or a dependency with limited support.
System boundaries and component interactions. A separate payment service and order service express a view of the business: which component owns each fact, where a transaction begins and ends, and how failures cross the boundary. AI can propose and challenge that design. The team must reconcile it with the actual product and operating model.
Data modeling and database architecture. A schema favors some queries and makes others more expensive. Supply the known workload and plausible future uses; ask for the assumptions behind indexes, storage choices, and migrations. Record which changes in the business would justify revisiting the design.
Security and authentication. Identify the assets, trust boundaries, regulatory requirements, and acceptable user friction. An AI assistant can help analyze threats when given this context. People responsible for the service still need to judge the assumptions and verify the controls.
Scaling and performance. Expected traffic, bursts, and latency targets need a basis in the product and its operations. AI can explore capacity strategies and help construct tests. The team decides which targets matter and whether the measurements support the proposed design.
A team can give an agent freedom to choose an internal helper implementation while reserving changes to a public interface or trust boundary for an explicit decision.
Use constraints to delegate effectively
For a service with these existing architectural choices:
We use PostgreSQL. Our services communicate via gRPC. Authentication goes through the gateway service. All database access goes through the repository pattern.
That gives an agent useful direction. It also gives a reviewer questions to ask. Did the change add another persistence mechanism? Does it bypass the gateway? Are database calls still behind the intended interface? A generated test deserves the same inspection: does it exercise the requirement, and would it fail if the boundary were violated?
AI's speed is most valuable when the direction is already set. It can draft components, integration code, tests, and performance improvements within that architecture. The engineer who keeps those changes coherent avoids the rework of discovering later that a feature conflicts with the rest of the system. That is how architectural discipline helps a team ship faster.
An AI that generates code in the wrong architectural direction generates technical debt at the speed of autocomplete.
If a requirement appears to demand changing the architecture, ask the agent to identify that conflict and propose the change explicitly.
Human judgment supplies the long-term direction; AI expands what the team can implement within it. That division of labor produces better systems than either party working alone.
Keep the rationale with the decision
I have watched teams lose architectural coherence when choices entered through feature implementations without a shared decision. One engineer accepted an implementation because it worked; another did the same for a different feature. After a few months, the codebase had three approaches to data access, two conflicting authentication mechanisms, and no one could explain why.
Write the decision where the team and its tools can find it. An architecture decision record, or ADR, preserves the problem, selected approach, alternatives, and consequences. A repository instruction file can point to the relevant record and state the constraints for routine work. Update both when the decision changes so the next session does not receive conflicting guidance.
For the order service, the decision record should capture the gateway’s responsibility and the authorization checks the service owns:
Decision: Authentication boundary for the order service
Status: Proposed; the service team must review before acceptance
Context:
The gateway authenticates incoming requests. The order service still
needs to authorize each action against the requested order. In this
example, customers may read only their own orders.
Proposed boundary:
The order service accepts identity only through the gateway's trusted
path. It does not trust identity headers from arbitrary callers.
It checks whether that identity may access the particular order.
Alternative to evaluate:
Have the order service authenticate external requests directly.
Compare duplicated validation, revocation handling, and exposure.
Consequences to evaluate:
The order service depends on the gateway's identity path. A gateway
outage can interrupt access. The order service must still maintain
and enforce its authorization rules.
Evidence required:
An authenticated customer cannot read another customer's order.
A caller cannot bypass the gateway and assert another identity.
Missing or invalid identity produces the defined denial response.
Gateway failure has an explicit, tested response.
Revisit when:
The order service needs direct external callers or a new trust boundary.
Authenticating a caller and authorizing access to an order are separate responsibilities. Before accepting this record for a real service, specify its trusted transport, credential format, and denial response, then test those choices.
For a code change, ask the agent to identify which decision it relies on, which files implement that decision, and which checks would catch a violation. Review the answer against the code. If the rationale is missing, reconstruct it from available evidence before presenting a guess as an established requirement.
Keep authority connected to understanding
Expanded May 21, 2026.
Active system understanding gives architectural authority substance. An engineer can learn a system produced by an agent, just as they can learn one inherited from another team. They need to trace its behavior, inspect its dependencies, and exercise its failure paths before making consequential changes.
Systematic quality standards help the team determine whether implementation meets the decision. Review the checks alongside the design, including conditions that the existing suite may have missed.
The self-improving system principle concerns improving the practice as well as the software. When a review exposes a missed assumption, add the relevant test or revise the decision record. Record why the assumption failed and what would change your decision next time. Those lessons give the next engineer and the next agent something concrete to use, while sharpening the judgment of the person doing the work.
Before accepting a consequential change, have another engineer explain the decision from the record and trace it into the implementation. If they cannot tell what the system is committed to, the architectural work is still unfinished.