Our hiring process was not broken in an obvious way. It produced reasonable outcomes and we had learned to live with its inefficiencies. But over time the cost of running it became impossible to justify. I could have looked the other way. But I have always believed in leaving the battlefield better than I found it. This is the story of how we identified its shortcomings, redesigned the process around our actual constraints, and handed ownership of it to the entire team.

Senior engineering management is mostly subtraction. The brief you don’t over-specify. The standard you don’t leave verbal. The conversation you don’t have because the team is already having it.

But subtraction is not absence. It only works when the infrastructure underneath is honest: a clear end state, written standards, accountability that survives your calendar, and protection from the org above. This is the version of the job I’ve been learning the hard way.

A senior engineer stepped into a first-time lead role and discovered that the real shock was not fewer hours of coding. It was realizing that a full day could be spent reviewing, mentoring, estimating, and unblocking, yet still feel invisible because the work had shifted from personal output to other people’s growth.

This piece is about that shift: what I had to trade when speed stopped being my main source of value, and why the manager side of the role turned out to be harder than I expected. It is also about what makes that transition more complicated in an AI-heavy code review culture, where code can look polished long before the underlying fundamentals are solid.

Onboarding onto a large LMS codebase, I used Cursor not to write features faster, but to build a mental model: where legacy PHP meets newer REST layers, how events propagate, and where permission checks actually live.

This post walks through two real explorations (user impersonation across stacks and a permissions trace), with anonymized prompts, what the tool got right and wrong, and a small playbook you can reuse on your own brownfield project.

You bump a version, run install, and the project catches fire. That’s a React upgrade.

Half the bugs you find were already there — the rest is types, tests, and Claude Code keeping the investigation from eating you alive.

A young engineer asked me a deceptively simple question. Years in the problem, and the answer came out as a fumble.

Every short definition slips. Architecture is not the diagrams, not a phase, not one person’s role. It is the practice of deciding which tensions to accept. Organizations and systems co-evolve. The architect’s value lies in building that capacity in teams, not owning every decision.

This is the answer that took almost four months to write: why the question resists a tidy definition, and why that resistance is the most honest signal we have about where architecture actually lives.