The New Engineering Frontier: From Syntax to Strategy

[TODO: Rafael, this needs your real opening. What actually triggered this post? A 1:1 with a junior engineer asking what they should be learning now that AI writes the boilerplate? A hiring debate about what to test for in interviews? A moment reviewing AI-generated code that was better than what a junior on your team would have written? Give me the who, when, and where, and I’ll open on that scene instead of the paragraph below.]

I’ve started telling every junior engineer who asks me for career advice the same thing: stop grinding your syntax and start building your judgment. Writing correct code, the kind of thing that used to take years of banging your head against a compiler to get fluent at, is turning into a commodity. An AI assistant can produce serviceable boilerplate faster than any of us can type it. So the old career ladder, the one where you proved yourself by memorizing a framework or surviving enough production incidents to earn the “senior” title, is being rewritten under our feet.

I don’t think that’s a bad thing, and I know that’s not a popular take with people who spent a decade earning their syntax scars. But the shift is real, and pretending it isn’t happening does nobody any favors. What’s actually happening is that the bar is moving up the stack, from “can you write this” to “should this be written at all, and does it matter.” That is a much harder skill to teach, and it’s the one I think we should be teaching first now.

I’ve seen the opposite mistake plenty of times too, so let me be clear this isn’t new. Long before AI could write a for loop, I watched teams fall in love with the architecture and forget about the business paying for it. [TODO: this is the part I really don’t want to invent. You mentioned a case of a “pristine codebase for a product that shipped after the business went bankrupt.” Was that a team you were on, a team you led, or one you heard about secondhand? What was the product, roughly when did this happen, and what actually killed it: the timeline, the market, something else? I need the real version before I can put it in the post, this is the strongest anchor the whole piece is missing.] Perfect code that ships two years late isn’t an engineering win. It’s a liability with good test coverage.

That old trap is exactly why I think the AI shift, for all the anxiety around it, is pointing us somewhere healthier. If the easy 80% of the code is going to get faster to produce no matter what we do, the only sane response is to stop spending our best thinking on it. The 80/20 rule for engineering has always been true, most of the customer value in any system lives in a small, gnarly slice of business logic, and the rest is plumbing. What’s changing is that we finally have a tool that’s honest about which is which. Spend your attention on the 20%, let the assistant draft the plumbing, and review it like you’d review a smart but context-blind junior, because that’s roughly what it is.

Product empathy is the second piece, and it’s the one I think gets skipped most often because it doesn’t feel like “real work” to a lot of engineers. It means asking what the person clicking the button is actually trying to do, before you touch the ticket. [TODO: got a real example here? A time you or someone on your team pushed back on a ticket, or killed a feature, because the product empathy question surfaced that it didn’t need to be built at all? That would land so much better than the abstract version I’ve written.] I’ve pushed engineers to ask that question in refinement, out loud, and it’s uncomfortable at first because it sounds like second-guessing the product manager. It isn’t. It’s the difference between an engineer who executes tickets and one who can be handed a problem instead of a spec. That second kind of engineer is the one who’s going to matter more, not less, as the syntax layer gets automated away.

And then there’s speed as a feature, which is the one that makes engineers who grew up on “do it right the first time” the most uncomfortable. In a competitive market, being directionally correct and fast beats being perfectly right and late, almost every time. [TODO: do you have a real instance of this from your own career, shipping something rough on purpose to test a hypothesis, and it paying off (or not)? Even a rough one-liner would help ground this section.] Technical debt, in this framing, stops being a shameful accident and becomes a deliberate bet: I am choosing to carry this cost now because proving the hypothesis matters more than the cleanliness of the proof.

None of this is permission to write garbage on purpose and call it strategy. Sloppy code that nobody can safely touch again is still sloppy code, and speed you can’t sustain isn’t speed, it’s a countdown. The judgment call is knowing which corners are cheap to cut and which ones you’ll be paying interest on for years, and that judgment is exactly the strategic muscle I’m talking about. It’s harder to teach than a design pattern, and it’s the thing that’s actually going to separate engineers from here on.

So if you’re mentoring someone junior right now, or you are that someone junior, my advice is the same either way. Learn the syntax, sure, you still need to read the code the assistant hands you. But spend your real energy on the 20% that matters, on asking why the button exists before you build it, and on knowing when fast and rough is the right call. That’s the job now.