architect

architect: decide the shape once, before the code hardens it

Architecture is the set of decisions that are expensive to reverse. Make them deliberately, record them, and keep the map current. Each one settles only after the critical-thinking moves, so the decision record's options section holds what actually competed. Scale the depth to the project: a small tool needs a page; a platform needs the full pass.

The pass

1. Boundaries. Cut the system into modules along the domain's natural seams (what changes together lives together). Per module: what it owns, what it exposes, what it may never reach into. These rules become mechanically enforced when the stack's tooling allows (import restrictions: wire via stack). Shape modules for agent legibility: deep modules behind small interfaces, one folder per module with its public interface on top, so an agent can use a module without reading its internals. Test at the boundary (grey-box): those tests survive refactors and agent rewrites of the inside alike.
2. Data. The core entities, who owns each, where truth lives, what is derived. Personal data flagged per entity (feeds the compliance register). Retention and deletion are schema decisions, not afterthoughts.
3. What it decides. Does this system decide anything with consequence for money, rights, safety or a legal obligation? "Nothing of weight" is a complete answer and closes this step. Otherwise, per decision: where that logic lives, and whether the owner can read it there without reading code. Logic only its own code can state is a finding, not a detail. A decision about a person with legal or similar effect also feeds the compliance register.
4. Contracts. Every integration (API, queue, file, third-party service): the contract, the failure mode, the timeout/retry stance, and what the user sees when it's down. A contract without a failure plan is half a contract.
5. Environments. Local → test → production: what exists, what differs, where config and secrets live per environment, how data gets seeded. One command to run locally, documented.
6. Observability. Decide now what gets logged, measured and traced: correlation IDs from every entry point, the golden signals (rate, errors, latency) on the critical flow, and where a human sees failures. Instrumentation is an expensive-to-reverse decision: built during construction, verified at launch by maintain, never bolted on after.
7. Threats. A lightweight pass over the real risks: who can reach what, where untrusted input enters, what the abuse cases are, what the blast radius of a leaked credential is. Mitigations become requirements in specs, not wishes.
8. The 10× question. Where does this design break at 10× the users/data? Mark those spots with defer: markers (ceiling + upgrade trigger) instead of building for scale now.