You Got Promoted to Architect. The Job Is Pushing Back on Requirements.

The welcome screen took fifteen seconds to appear. Nothing had crashed. No error in the logs, no 500 in the network tab, no memory spike. The page was essentially static: a logo, a permissions button, one sentence of explanation. Fifteen seconds, because of one line of logging.
A developer on the team wanted to see how many people installed the add-on each week, so they asked an AI assistant to log the install. Reasonable request. The model wrote a careful, defensive chain: try to read the user's email if they consented during install; if that fails, try their user ID; if that fails too, log an install event saying we know someone showed up but not who. Three branches, one line each.
What the code doesn't show is what sits behind each branch. Every one of those calls is several requests to Google's servers, and the platform had spent the previous year tightening exactly what an add-on is allowed to learn about a user. So the first moments of a brand-new user's life were spent on a sequence of network round trips that were mostly going to fail.
Mani Doraisamy wrote this up on DEV under a title that should be a job posting: We promoted developers into architects without informing them. His diagnosis is the part worth keeping: the welcome screen wasn't an AI bug. It was an architecture decision made by default, because nobody made it on purpose.
What the model was optimizing for
Coding agents are extremely good at one thing: implementing the requirement you stated. They're also tuned for two non-functional goals whether you mention them or not — security, and not breaking what already works. Those are sensible defaults. They're also, on a hot path, expensive ones.
The model in this story was being careful. It didn't assume consent. It didn't crash when a field came back missing. It recorded that something happened even when it couldn't identify who. Every one of those decisions is defensible on its own. Together, they cost fifteen seconds at the exact moment a stranger decides whether your product works.
Three things the model could not see:
- Volume. Whether this code runs 40 times a day or 40,000 times a minute.
- Budget. Whether the install path has 500 milliseconds or 5 seconds to spend.
- Consequence. Whether a marketing follow-up email is worth making every new user wait for.
None of that was in the prompt. So the agent filled the gap with the most conservative, most defensive, slowest option that still satisfied the words you typed. It didn't push back, because pushing back isn't part of the loop. It's part of yours.
When a requirement becomes an architecture decision
Most requirements are just work: rename a field, add a column to a report, fix a label. A small number change the shape of the system. Those are the ones you have to catch before the prompt, not after the pull request.
Here's the test I use — four axes. If a requirement moves any of them, it's an architecture decision, and it gets written down.
- Latency budget. Does this add work to a path a user is waiting on? Install, sign-in, first page load, checkout. Each of those needs a number attached — p95 under 500ms, say, where p95 means 95 out of 100 requests finish within that time. Any requirement touching those paths has to fit inside the number or move off the path.
- Call fan-out. Does this multiply the number of network calls behind a single line of code? A logging statement that becomes three fallback branches, each doing two round trips, is a fan-out change even though the diff is four lines long.
- Data model churn. Does this need a new table, a new column, a new version of an existing record? Agents are cautious about deleting and generous about adding. Two columns that mean almost the same thing is the most common shape of AI-generated technical debt I see.
- Trust surface. Does this accept input from somewhere new, or let a request through without authentication? This is the axis agents are most conservative about, and their conservatism is usually correct. Don't fight it — design around it.
The logging request moved two of the four. It put work on a path that had no written budget, and it turned one line into a fan-out. That's why the bill came to fifteen seconds instead of a code review comment.
Write the constraint brief before the prompt
One page, kept next to the repo, updated when it stops being true. Not a forty-page design document. A page.
- The three paths that matter. Name them and attach a number to each. Install: p95 500ms. Sign-in: p95 800ms. Dashboard load: p95 2s. Everything else is negotiable.
- The canonical data model. Tables, what a row means, what is allowed to change. Include the sentence explicitly: one users table, new fields require a migration and a note, do not create a parallel table.
- Sync or async, by default. Telemetry, analytics, emails, webhooks: async unless there's a stated reason otherwise. Say it once so you don't have to repeat it in every prompt.
- What is allowed to be unauthenticated. Name those endpoints. If you don't, the agent assumes none of them — and you get a sign-in wall in front of your own welcome screen.
- Evidence of done. A test that fails before the change and passes after beats a model saying it looks right. For anything touching the three paths, a timing check, not just a unit test.
Then the prompt changes shape. Instead of 'log new installs', it becomes: log new installs, async, timestamp only, must not add a network call to the install path, no new tables. Same feature. Very different diff.
Review at the seam, not the line
You can't read every line an agent writes, and trying is how teams end up slower than they were before they adopted agents. What you can do is review the seams — the places where a change meets the rest of the system. Four things you can grep or eyeball in a diff:
- New network calls inside a path that has a latency budget.
- New tables or columns, and whether anything was migrated or just added alongside the old thing.
- New try/catch chains, especially sequences of fallbacks — every branch is a hidden round trip.
- New third-party calls, and what the code does when that service is slow.
That review takes minutes and catches the fifteen-second class of bug. Reviewing line by line takes hours and mostly catches typos.
The hiring question that predicts seniority
If the architect's real job is pushing back on requirements, interview for it. Give a candidate a feature request that is technically easy and quietly expensive — marketing wants the user's email captured at install — and then listen.
A mid-level candidate starts sketching the try/catch. A senior one asks how many installs you get per day, what the install path's latency budget is, and whether an email captured one screen later would be good enough. Both answers are valid code. Only one of them is the job. The difference isn't language experience; it's the habit of costing a requirement before building it.
This matters more, not less, when the team is distributed. A written constraint brief travels across time zones intact. A verbal 'be careful with the install path' does not. If you run a near-shore team alongside an on-shore product group, the brief is the interface — the thing that lets a developer six hours away make the call you would have made without a meeting.
Where this goes wrong
The trade-off, stated plainly: pre-specifying architecture costs time, and it can make things worse. Three failure modes worth naming.
- Over-constraining. If the brief specifies the implementation, the agent can't propose a better shape. Constrain the boundaries — budgets, data model, trust surface — and leave the interior alone.
- You become the queue. If every change needs an architecture sign-off, you've rebuilt the review bottleneck AI was supposed to remove. Reserve the brief for the four axes; let everything else ship.
- Constraint rot. A brief that was true at launch and that nobody has read since is worse than no brief, because people trust it. Re-read it quarterly, or the moment a number stops matching reality.
The alternative — no brief, prompts only — doesn't give you freedom. It hands the decision to the model. And the model will pick the safe, general, slow answer every time, because it has no idea which path a stranger is waiting on.
Key Takeaways
- A single 'one-line' logging change cost 15 seconds on an install path — roughly thirty times a reasonable 500ms budget — because each fallback branch hid several network round trips.
- Agents implement your functional requirement and default to security plus backward compatibility. They don't know your traffic volume, your latency budgets, or whether a marketing email is worth a wait.
- Test every requirement against four axes: latency budget, call fan-out, data model churn, and trust surface. If it moves one, it's an architecture decision, not just a task.
- Write a one-page constraint brief: three timed paths, the canonical data model, sync/async defaults, permitted unauthenticated endpoints, and what counts as evidence of done.
- Review seams rather than lines: new network calls on hot paths, new tables and columns, fallback chains, third-party timeouts.
- Interview for pushback. Ask candidates to cost a requirement before they code it — that's the line between the coding job and the architect's job.
- Watch the trade-offs: over-constraining blocks better solutions, sign-off queues rebuild the bottleneck, and stale briefs are trusted lies.