The Top Skill Engineers Should Be Developing Right Now

AI has dramatically changed how software gets written.

Code generation is fast. Ideas can become implementations in minutes. Entire features can appear with a few prompts.

But this speed introduces a new risk: bad systems produce bad output faster than ever.

That’s why the top skill engineers should be developing right now isn’t simply writing code.

It’s stewarding the system that produces the code.

Watch the Presentation

I originally shared these ideas in a presentation with our team at Lambda Curry.

The goal was to introduce the concept of system stewardship and challenge engineers to think beyond simply completing tickets. We explored how engineers can create compounding impact by improving the systems that generate and shape the code we write.

In the presentation I walk through:

why AI makes system thinking more important than ever how small changes to prompts, rules, and context dramatically improve generated code a real example of how the “research loop” engineers can use to iterate toward better architectures how teams can collaboratively improve their development systems over time

If you’re interested in how engineering roles are evolving in the AI era, the talk gives a deeper look at the ideas behind this article.

From Ticket Executor to System Steward

The traditional workflow for engineers has been simple:

• Pick up a ticket
• Implement the solution
• Move on to the next task

This produces linear output. Every engineer contributes work, but the system itself doesn’t improve.

Tomorrow, the same mistakes appear again.The same friction slows people down again.The same architectural issues surface again.

System stewardship introduces a different mindset.

Instead of asking: “How do I complete this ticket?”

You start asking: “How can I improve the system so this problem is easier to solve next time?”

That small shift turns linear work into compounding impact.

The New AI Performance Curve

AI has created a strange new spectrum of engineering performance.

On one end are engineers who avoid AI entirely. They will increasingly struggle to keep up with the speed modern teams expect.

Next are engineers who use AI poorly. These engineers often produce large amounts of code quickly, but without strong judgment or system awareness.

You might call this the slop cannon phase — spraying plausible-looking code everywhere without improving the underlying system.

At the far end are engineers who use AI effectively.

These engineers don’t just generate code. They shape the environment that generates the code.

That’s where stewardship begins to matter.

A Simple Example: The useEffect Problem

AI models frequently generate React code using useEffect. It’s one of the most documented hooks, and it often appears in examples across the internet.

But in frameworks like Next.js and React Router 7, reaching for useEffect can often be a sign that something isn’t being done the right way.

We started noticing that useEffect kept appearing in generated code.

The problem wasn’t that engineers were writing bad code. The problem was the system generating the code lacked the right context.

Here’s what was happening:

• Our development agent had a research phase
• The research phase would search for “the React way”
• The planning phase used that research
• The generated code followed the plan

The missing piece?

The research phase wasn’t required to consult our project’s codebase rules or framework conventions.

So the system behaved exactly as designed:

• It researched generic React
• It planned generic React
• It produced generic React solutions

Stewardship meant recognizing this wasn’t a coding issue. It was a system design issue.

The fix was small:

• Ensure research consults codebase rules
• Update prompts to reference framework conventions
• Improve review tooling to critique plans, not just code

A few lines of context dramatically changed the quality of output.

Revision Is the New Superpower

Traditional engineering emphasized testing as a feedback loop.

In the AI era, revision of the system itself becomes the highest-leverage loop.

Every task should create an opportunity to improve the system.

Questions worth asking after finishing work:

• Where did friction appear?
• What did the AI misunderstand?
• What patterns did we correct manually?
• What rule or context could prevent that next time?

When engineers consistently revise the system, improvements accumulate across the entire team.

Without revision, the same problems repeat forever.

The Mohsen Research Loop

One of the most valuable patterns engineers can adopt today looks something like this:

• AI proposes a solution
• The engineer notices complexity or an anti-pattern
• The engineer challenges the approach
• The solution is iterated multiple times
• A simpler architecture emerges

But stewardship adds an important final step:

• Update the system so the better approach happens automatically next time

• If that learning stays in one engineer’s head, it doesn’t scale.

• If it becomes part of the system, the entire team benefits.

Pair Planning Becomes More Valuable

When AI tools are involved, planning becomes far more powerful.

Instead of discovering architecture problems during implementation, teams can surface them early.

Pair planning creates a shared environment where engineers can:

• challenge assumptions
• refine architecture
• expose hidden complexity
• align on best practices

This isn’t supervision or criticism.

It’s collaborative system design.

Every planning conversation strengthens the system engineers are building together.

Stewardship Creates Compounding Impact

The biggest difference between good engineers and great engineers today isn’t how many tickets they complete.

It’s whether their work improves the system for everyone else.

Stewardship might look like:

• improving prompts that generate code
• refining development agents
• documenting patterns discovered during implementation
• introducing tests that prevent recurring issues
• improving architectural conventions
• sharing insights with the team

Each small improvement makes the next task easier.

Over time, those improvements compound.

We Build the Machine Together

The most important mindset shift may be this:

Your job isn’t just fixing a bug.

Your job is helping ensure the system doesn’t produce that bug again.

In the AI era, engineers are no longer just authors of code.

They are designers of the systems that produce it.

And the engineers who learn to steward those systems will have the greatest impact on their teams.

Mar 5, 2026.