In-depth articles on technology shaping what comes next.

Developer vs Architect: When Each One Wins

Developer vs architect isn't about titles — it's who owns architecture decisions. ADRs, coupling, and reversibility for your surprise promotion.

Overhead illustration of a desk with two diverging paths of light, one tangled and one clean.
The typing part got fast. The deciding part is the job now.

Last month I reviewed a diff where an AI coding assistant had written a chain of try/catch blocks to log new installs for a browser add-on. First it tried to grab the user's email. If that threw, it fell back to a user ID. If that threw, it logged a shrug: someone installed, we don't know who. The code worked. The code was also wrong, because the platform had recently tightened what identity data an add-on can even ask for. The developer vs architect question hides in diffs exactly like this one — and nobody sent you the memo about which side of it you're on now.

The right answer wasn't a better catch block. It was logging a timestamp, showing a welcome screen, and telling marketing they can't have the email at install time unless the user hands it over later. No model makes that call, because the model doesn't know your users, your platform's policies, or your marketing team's quarterly goals. It does exactly what you ask, at frightening speed. Which means the person doing the asking — that's you — just became responsible for something bigger than code. Congratulations on the promotion. Sorry nobody told you.

There's a fair counterargument: plenty of engineers will tell you every job they've had expected them to push back on requirements and design the data model for whatever ticket they picked up. True — at good teams, that was always the work. But something real has changed. Typing speed used to be a natural throttle on bad ideas. When a mediocre plan costs three days of implementation, you think about it first. When it costs ninety seconds, the plan gets built before anyone has had the thought. The friction that used to force architectural thinking is gone, and nothing has replaced it except you.

Developer vs Architect: Two Different Jobs

Here's the cleanest way I can put the difference. A developer takes a ticket and asks how. An architect looks at the same ticket and asks whether it should exist, and in what shape. The developer optimizes inside the constraints. The architect chooses the constraints — and, crucially, owns the consequences of that choice for the next two years. Both are real engineering. They're just different jobs, and they fail in different ways. A developer failure is a bug. An architect failure is a data model with redundant tables that three teams have built on top of by the time anyone notices.

AI coding tools have quietly slotted themselves into the developer seat. They're the fastest junior you've ever hired: tireless, fluent, and completely unwilling to tell you that your requirement is the actual problem. Ask for per-user install logging and you'll get per-user install logging, with a cascade of fallbacks to make sure it "works" even when the platform doesn't want it to. The model has no stake in your app's latency budget, your privacy posture, or your on-call rotation. That's not a flaw in the tool. It's the job description of the seat it took — which means the other seat, the one that says no, is vacant unless you sit in it.

So what does sitting in it actually look like? Three things, mostly. Knowing your users well enough to spot when a requirement contradicts their interests. Knowing your system's coupling well enough to see a one-line change's blast radius. And being willing to have the awkward conversation with whoever wrote the requirement — before the code exists, not in a postmortem. None of these involve drawing boxes-and-arrows diagrams in a wiki nobody reads. All of them involve judgment that can't be delegated to a tool that never pushes back.

Architecture Decisions You're Already Making

You don't need the title to be making architecture decisions — you're making them every week, inside ordinary tickets. Where validation lives (client, API, or database). Whether a call is synchronous or queued. What gets logged and what deliberately doesn't. The shape of a new table and what it foreign-keys to. Each of these is a bet about the future, and each one either constrains or enables the next ten tickets. The install-logging diff looked like a monitoring task. It was actually a privacy decision, a security decision, and a product decision wearing a one-liner costume.

Here's the before — what the assistant produced, faithfully implementing "log who installed":

async function logInstall(req, res) {
let identity = null;
try {
identity = { email: await getUserEmail(req) };
} catch {
try {
identity = { userId: await getUserId(req) };
} catch {
identity = { note: "install without identity" };
}
}
await db.installs.insert({ ...identity, at: new Date() });
res.redirect("/welcome");
}

Fifteen lines, three failure modes, and a schema that has to accommodate email-or-userId-or-neither forever. Each fallback quietly couples the install path to an identity API, so an outage in a consent-gated service can now slow down or break your onboarding funnel. And the row that says "someone installed, we don't know who" is analytically useless — it tells marketing nothing they can act on. The requirement was satisfied literally and defeated in spirit.

async function logInstall(req, res) {
await db.installs.insert({ at: new Date() });
res.redirect("/welcome");
// Email is collected on the welcome screen, with consent,
// posted asynchronously — and never gates the install path.
}

The after is four lines. But notice what actually changed: not the code, the requirement. The goal was never "capture an email" — it was "measure installs and follow up with new users." A timestamp measures installs. The welcome screen, where the user is already looking at a consent surface, is the right place to ask for the email, asynchronously, where a failure costs nothing. The architect move wasn't writing less code. It was renegotiating what the code was for.

A habit worth building: before any non-trivial change, do a two-minute coupling inventory. Ask what this code will call, what will call it, and what breaks when each of those is slow, down, or deprecated. In the before version, the install path depended on two identity services it had no business knowing about. In the after version, it depends on one table. That dependency count — not line count, not cyclomatic complexity — is the number that predicts your future incidents. We've seen the same pattern in how AI coding assistants fail in predictable, testable ways: the output is locally plausible and globally coupled.

ADRs vs Tribal Knowledge: When Each Wins

An Architecture Decision Record is deliberately boring: one page with the context, the decision, the alternatives considered, and the consequences accepted. That's it. No ceremony, no sign-off workflow unless you want one. The reason ADRs have gone from nice-to-have to mandatory in the AI era is memory. The model has none. Six months from now, someone will point an assistant at the install module, ask for a change, and the careful reasoning about consent and platform policy will evaporate — unless it's written down where both humans and tools can find it. An ADR in the repo gets read by whoever (or whatever) touches the code next.

Tribal knowledge genuinely wins in some situations, and pretending otherwise is how ADRs got their bureaucratic reputation. A two-person team building a prototype with a lifespan measured in weeks doesn't need decision records; the decision-makers are sitting next to each other and the code will be rewritten anyway. Verbal context is faster, richer, and cheaper at that scale. The trouble is that teams rarely notice the moment they cross the threshold — the first new hire, the first team consuming your API, the first incident where "why did we do it this way?" has no answer.

  • The decision is expensive to reverse — schema changes on live data, public API contracts, vendor lock-in.
  • The decision crosses a team boundary, so the people affected aren't in the room when it's made.
  • You can already hear the future question: "why on earth did we do it like this?"
  • An AI tool generated the implementation, so no human ever had to articulate the reasoning out loud.
  • The trade-off is non-obvious — you're accepting a real cost (latency, privacy surface, operational burden) on purpose.

That fourth item is the one that's new. When a human writes code, the reasoning leaves traces — commit messages, PR arguments, the shape of the attempt itself. When an assistant writes it, the reasoning exists only in your head, briefly, and then nowhere. The ADR is the artifact that makes review possible, because it gives reviewers something to check the code against. Without it, review degrades into style nits while the architecture drifts.

Notebook with hand-drawn box-and-arrow diagrams and a fountain pen in soft window light.
An ADR is one page that survives long after the diff is forgotten.

Reversible vs Irreversible Decisions in System Design

The single most useful question in the architect's kit is this: how expensive is it to change my mind? Some decisions are two-way doors. A log format, an internal function signature, a caching TTL — walk back through them any afternoon. Others are one-way doors. A public API contract that external clients integrate against. A database schema that has accumulated six months of production data. A consent flow your legal posture now depends on. Once you're through a one-way door, the cost of reconsidering isn't a refactor — it's a migration, a deprecation schedule, and an apology.

Classify the door before you build, because AI has made building cheap and un-building is as expensive as ever. Left unconstrained, an assistant will happily design your data model for you — and the failure mode is redundant tables, duplicated columns, and migration code stacked on migration code, because each prompt adds a table rather than reconsidering the model. Deleting a table with live data that three services read is one of the most miserable operations in our industry. The cheap generation of the schema is exactly why the schema deserves expensive thought. Spend your deliberation budget in proportion to irreversibility, not in proportion to how long the code takes to write — that ratio has inverted.

My working rule: if a decision touches data you can't re-create, or an interface someone outside your team will depend on, it gets an ADR and a second pair of eyes before implementation starts. Everything else gets shipped and iterated on. This rule scales from a solo project to a platform team without modification, and it's the difference between moving fast and moving fast in a direction you can't leave.

Pushing Back on Requirements Like an Architect

The uncomfortable core of the architect's job is saying no to people who outrank you. "Log who installed" sounded like a requirement; it was actually a solution someone had pre-imagined for the goal "measure installs and follow up with new users." Architects translate solutions back into goals, then offer a cheaper path to the goal. That translation is the whole trick, and no tool does it, because the tool's entire design is to comply. Some engineers load their assistant with user context and get decent judgment out of it — that helps at the margins, but the model still won't walk into a meeting and tell marketing their follow-up email isn't happening at install time.

  1. State the goal back, not the solution: "we want to measure installs and reach new users."
  2. Offer the cheaper path and what it delivers: timestamp logging measures installs perfectly.
  3. Name what the expensive path actually costs: consent friction, a coupled install path, rows marketing can't use.
  4. Give them a real choice: "if the email matters, we ask on the welcome screen — here's the one-day version of that."
  5. Write down whatever is decided, so the next person doesn't relitigate it from scratch.

Now the honest objection, because it deserves air: nobody got promoted. The likelier story is that you're becoming the liability sink for decisions a model made, at the same salary, with less of the fun part. I don't think that's wrong — I think it's a reason to take the documentation habit seriously rather than skip it. An ADR trail is also a paper trail. Being the human who decided is only a liability when you can't show your reasoning. The person who wrote down "we chose timestamps over email capture because the platform restricts identity data" is covered. The person who merged whatever the assistant emitted is not.

Developer vs Architect: When Each One Wins

This isn't a ranking — it's a mode switch, and the skill is knowing which mode the work in front of you needs. Some concrete cases from my own backlog:

  • Well-specified bug fix, known blast radius: developer mode wins. Reproduce, fix, test, ship. Architectural deliberation here is procrastination in a blazer.
  • Prototype validating demand: developer mode. The code will be rewritten if it works and deleted if it doesn't. ADRs for a throwaway are waste.
  • Greenfield feature with fuzzy requirements: architect mode first, even if just for an hour. Fuzziness is where AI-generated momentum does the most damage.
  • Anything touching money, identity, or consent: architect mode, no exceptions. The cost asymmetry between building and un-building is at its worst here.
  • Schema changes on live data or public API changes: architect mode with an ADR, per the reversibility rule.
  • Two-person team, codebase younger than six months: developer mode with a running notes file. Full ceremony buys nothing yet.
  • Regulated domain or multiple consuming teams: architect mode with records, because "why" will be asked by auditors and strangers, not friends.

The failure mode in both directions is staying in one mode. Developers who never switch up ship elegant implementations of the wrong thing. Architects who never switch down produce diagrams for systems that don't exist. The people I'd least want to lose on a team are the ones who do both in the same afternoon — argue about the data model at 10 a.m., then fix the off-by-one at 2 p.m. without complaining that it's beneath them. If you're building your review process around AI output, it's worth reading about how agentic coding tools structure loops, context, and permissions, because the mode switch has to happen inside that loop, not after it.

AI will happily build the wrong thing at high speed, forever. The architect's job is to decide what the right thing is — and to write down why before the reasoning evaporates.

A blueprint with glowing connection lines between drawn shapes, unrolled beside a laptop.
Architecture is deciding which lines are allowed to exist before anyone draws them.

The Recommendation: Take the Promotion

Here's my position, and it's not "it depends": default to architect mode for anything that touches your data model, an external contract, or your security posture, and stay in developer mode for everything contained. The split won't be 50/50 — for most engineers it's 20% architecting, 80% building, same as it always was. What changed is that the building got fast and the cost of skipping the 20% went up by exactly the speed multiplier. The more of the typing you delegate, the more of your value concentrates in the part you can't.

The starter kit is three habits, and you can install all of them this week. First, drop an ADR template in your repo — context, decision, alternatives, consequences, half a page — and write one the next time you accept a real trade-off. Second, add a two-minute coupling inventory to every epic: what does this call, what calls it, what breaks when those fail. Third, put the reversibility question in your ticket template: "if this is wrong, what does changing our mind cost?" If the answer is "a migration and an apology," slow down. If it's "an afternoon," don't.

The coding job isn't going away — the typing job is. Those were never the same thing, and the people quietly panicking are the ones whose role had quietly shrunk to translating tickets into syntax. If you're reading diffs and asking "why is this coupled to an identity API," you were already doing the architect's job. The only real change is that now it's official, it's documented, and it's yours. Take the promotion.