Something Changed

Something changed in software engineering over the last two years. Not gradually. Suddenly.

A lot of developers still think AI is just another productivity tool. Faster autocomplete. Better boilerplate generation. Smarter search.

I don't think that's what's happening. I think the economics of software development itself are changing.

When AI can generate working code in seconds, code stops being the bottleneck. And when the bottleneck disappears, value moves somewhere else.

That shift is uncomfortable because most developers — including me at one point — built their identity around implementation. You write code. The code ships. The product improves. You become valuable.

That model made sense for a long time. Now the ground underneath it is moving.

The Moment I Started Seeing It Differently

In early 2025, Garry Tan talked about shipping hundreds of thousands of lines of production code in a short time using AI-assisted workflows. What stood out to me wasn't the number. It was the role he was actually playing.

He wasn't sitting there typing every line manually. He was directing systems, reviewing output, deciding what mattered, rejecting bad paths, and making trade-offs quickly. That is a very different job from traditional software engineering.

And once you notice it, you start seeing the same pattern everywhere. The best engineers are no longer just people who can implement quickly. They're people who can:

  • Understand ambiguity
  • Make decisions under uncertainty
  • Connect business context with technical execution
  • Move from idea → validation → delivery without waiting for five departments

The implementation layer is becoming thinner. Judgment is becoming heavier.

"I Write Code" Is No Longer Enough

This is the part many developers don't want to hear. Writing code is still important. Deep engineering still matters. Infrastructure, systems thinking, reliability, security — none of that disappears.

But writing code is no longer the scarce skill it used to be. The scarce skill is knowing:

  • What to build
  • What not to build
  • What users actually care about
  • Whether the solution creates meaningful outcomes

That changes the entire career equation. For years, many of us measured ourselves using output: commits, tickets closed, velocity, hours worked, frameworks learned.

I realized how flawed that was when I caught myself feeling productive for shipping features nobody actually used. AI exposed that brutally. Because once execution becomes fast, you notice very quickly whether the thinking behind the execution was good or not.

Bad ideas now fail faster. Which is actually useful.

The Rise of the Micropreneur

I think we're entering an era where developers need a different identity. Not freelancer. Not indie hacker. Not just "full-stack engineer." Something closer to a micropreneur.

A micropreneur is basically a one-person leverage engine. Someone who can combine engineering, AI systems, product thinking, user understanding, communication, and business awareness to create disproportionate outcomes.

The important part is this: they optimize for impact, not activity. That's a very different mindset from traditional engineering culture.

A traditional workflow often looks like this:

ticket → implementation → PR → deploy

A micropreneur operates more like this:

problem → hypothesis → prototype → feedback → iteration → outcome

The difference sounds subtle, but it changes everything. One mindset is focused on completing work. The other is focused on changing reality.

Why AI Pushes Developers Toward This Direction

AI dramatically reduces execution friction. You can prototype faster, validate ideas faster, automate repetitive work, compress development cycles, and explore more ideas with fewer people. That changes team dynamics. It also changes hiring.

We're already seeing companies look for engineers who can operate across product, design, AI tooling, systems, user experience, and business outcomes. Not because companies suddenly want everyone to become PMs. But because the translation layers are shrinking.

The engineer who understands the business problem directly becomes incredibly valuable. Especially in smaller, high-speed teams.

The Bigger Risk Nobody Talks About

There's another side to this shift. As AI gets better at generating answers, it's becoming easier to stop thinking deeply. That's dangerous.

I've noticed this personally too. Sometimes AI gives an answer that looks correct enough that your brain wants to accept it immediately. You stop interrogating the reasoning. You stop exploring alternatives.

That is probably one of the biggest long-term risks for developers. Because the future advantage won't come from typing faster. It will come from judgment, taste, systems thinking, prioritization, and critical reasoning.

AI can generate ten solutions. You still need to know which one should exist.

You still need to know which one should exist.

The Five Shifts That Matter

None of this happens overnight. Identity shifts happen through repeated behavior. These are the changes I think matter most.

1. Measure Outcomes, Not Output

Shipping isn't the goal anymore. Impact is.

Ask yourself:

  • Did this reduce friction?
  • Did users adopt it?
  • Did retention improve?
  • Did support load decrease?
  • Did revenue move?

A feature that nobody uses is not an achievement. It's just completed work.

2. Own the Problem, Not Just the Ticket

The developers who become extremely valuable are usually the ones who move upstream. They don't wait to be told exactly what to build. They try to understand user pain, business constraints, operational bottlenecks, and the actual reason something matters.

The quality of your understanding shapes the quality of your execution.

3. Build Judgment

AI increases the importance of decision-making. This means evaluating trade-offs, understanding long-term consequences, knowing when complexity is justified, and knowing when to kill ideas early.

One of the most underrated skills right now is stopping. Not every feature deserves to exist.

4. Ship Proof, Not Perfection

A lot of engineers still overbuild before validation. That becomes expensive in a world where experimentation is cheap. Sometimes a rough prototype teaches more in 48 hours than six months of planning.

Fast feedback loops matter more than polished assumptions.

5. Make Your Thinking Visible

Most developers stay invisible. They build quietly, but nobody sees how they think. That's becoming a disadvantage.

Writing, documenting decisions, sharing architecture trade-offs, explaining failures — these things create trust. Not because of "personal branding." Because visible reasoning becomes proof of capability.

A thoughtful engineering blog post often says more about a person than their GitHub contribution graph.

So What Happens Next?

I don't think software engineers disappear. I think the role expands. The future developer probably looks more like an operator, a systems thinker, a product-aware engineer, a technical strategist, or a micropreneur.

Someone who can move fluidly between idea, execution, validation, and business impact. The tools are getting cheaper. Execution is getting faster. That means judgment becomes the differentiator.

Not just technical judgment. Human judgment. The ability to decide what matters, what doesn't, what users actually need, and what is worth building in the first place. That may become the most valuable engineering skill of this decade.

At the end of the week, don't just ask:

"What did I ship?"

Ask:

"What changed because I was here?"

That question changes the entire game.

Next in CodeSense: "Judgment Is the Product" — why context engineering, decision-making, and taste may become more important than coding itself.