Scalable Human Blog

TL;DR: Addy Osmani’s recent piece on agents is one of the clearest reads I have found on working with AI agents responsibly. The big lesson: agentic engineering is not about outsourcing thinking, it is about sharpening it.

I recently read Addy Osmani’s article on X, and it has been stuck in my head ever since.

It is one of those pieces that gives language to things you have already felt while working with agents, but maybe have not fully systematised yet. The article is especially useful because it does not treat agents like magic. It treats them like powerful collaborators that still need direction, judgement, verification, and taste.

And honestly, it made me wonder: should we still be calling ourselves software engineers in this new world? Or are we slowly becoming Agentic Engineers, AEs instead of SWEs?

Mostly a fun thought. But maybe not entirely.

Good Prompting Is Critical Thinking

One of the strongest ideas from the article is that good prompting is not just a communication skill. It is a thinking skill.

Your prompt reflects your understanding of the problem.

If you cannot explain the task clearly, the audience, the constraints, what is out of scope, and what “done” looks like, there is a good chance the problem is not clear in your own mind yet.

That hit home.

Before asking an agent for help, it is worth writing your own brief first:

• Who is this for?
• What outcome do I want?
• What should not be included?
• What does success look like?
• What trade offs am I willing to accept?

That simple habit changes the quality of the output dramatically. Quality in, quality out.

Addy’s broader writing, which you can also find on his personal site, often has this practical engineering flavour: less hype, more useful patterns.

The Energy Is at the Front and the End

A line from my notes that keeps coming back to me is this:

The energy is in the front and end of a task.

That feels exactly right.

With agents, the middle can feel deceptively easy. You give a prompt, the agent generates code, drafts a plan, writes tests, refactors something, or explains a system.

But the real work sits in two places:

At the start, where you frame the task clearly.

At the end, where you verify, challenge, refine, and decide whether the work is good enough to put your name on.

This is where agentic engineering becomes different from simply “using AI.”

You are not just prompting. You are shaping a workflow.

Verification as a Habit

One of the most important phrases from the article is:

Verification as a habit.

That should probably be printed on the wall of every team using agents.

When a check goes green, do not just move on. Ask:

What did this prove?

Then ask:

What did it not prove?

That second question is where the value is.

A test passing might prove that one happy path works. It may not prove the edge cases are safe, the user experience is coherent, the architecture is sound, or the implementation matches the original intent.

This is where agents can help again. As Addy suggests in the article, verification is cheap. You can ask another agent to review the work, run tests, look for inconsistencies, or challenge assumptions.

A pattern I like:

• Ask the first agent to complete the task
• Ask a second agent to review it critically
• Ask for a list of assumptions and decisions
• Run the tests
• Ask what is still unproven
• Only then decide whether it is ready

That last step matters. The human still owns the judgement.

The Most Useful Question: “Did I Miss Anything?”

This is such a simple question, but it is incredibly powerful:

Did I miss anything?

Ask it often.

Ask it after you write a spec. Ask it after reviewing code. Ask it after summarising a meeting. Ask it before shipping.

Even better, ask a stronger model to answer it.

A frontier model can often spot gaps you were too close to see. It might notice missing constraints, unclear acceptance criteria, security concerns, UX issues, or mismatches between the implementation and the goal.

This does not mean the model is always right. It means it can expand your field of vision.

That is one of the best uses of agents: not replacing your judgement, but helping you notice where judgement is needed.

The Orchestration Tax Is Real

This idea might be the most practical one in the whole discussion.

Addy calls it the orchestration tax: the gap between what your agents generate and what you would feel comfortable putting your name on.

That gap matters.

If agents are producing more output than you can review properly, you are not moving faster anymore. You are accumulating risk.

As my notes put it:

When you are producing more than you can stand behind, you are no longer reviewing. You are hoping.

That is painfully accurate.

More agent sessions do not automatically mean more progress. Sometimes they mean more unfinished decisions, more half reviewed code, more pending judgement, and more cognitive debt.

The fix is not always to add more agents. Sometimes it is to slow down. Sometimes it is to tighten the checks. Sometimes it is to improve the prompt, add better tests, create clearer guidelines, or reduce the scope.

Agentic work still needs throughput discipline.

Taste Compounds Through Feedback

Another idea I loved is that when something does not meet your standards, you should not just fix it once and move on.

Capture why.

Put it somewhere reusable:

• A shared config
• A test
• A checklist
• A hook
• A prompt pattern
• A team guideline

That is how taste compounds.

If an agent keeps making the same mistake and you keep correcting it manually, the workflow is leaking. But if you turn that correction into a reusable rule, your system improves.

This is where experienced engineers have a big advantage. They have taste. They know what “good” looks like. The opportunity now is to encode that taste into the agent workflow.

Maybe We Are Becoming Agentic Engineers

The more I work with agents, the more I think the role is changing.

Software engineering is still software engineering. Fundamentals still matter. Systems thinking still matters. Debugging still matters. Taste still matters.

But the interface is shifting.

We are increasingly asked to:

• Define the work clearly
• Decompose tasks for agents
• Review generated output
• Verify assumptions
• Build repeatable checks
• Decide what is good enough
• Coordinate multiple AI assisted workflows

That starts to look like a new layer on top of traditional engineering.

Maybe “Agentic Engineer” is not such a silly term after all.

Not because agents replace engineers, but because engineers who use agents well need a broader skill set. Less typing everything by hand. More framing, guiding, checking, and owning the result.

You Do Not Need to Make It Heavy

One thing I appreciated is that the article does not imply you need a huge, rigid process.

You do not need to do all of this rigorously all the time.

Just plug in what works.

Start small:

• Write clearer briefs
• Ask for assumptions
• Use another agent to review
• Build verification into the workflow
• Capture recurring mistakes as rules or tests

That is enough to start improving.

The point is not ceremony. The point is better judgement.

Key Takeaways

• Good prompting is critical thinking. If your prompt is vague, your understanding may be vague too.
• Verification should be a habit. A green check is not the end. Ask what it proved and what it did not.
• Use agents to review agents. A second model can challenge assumptions, find gaps, and improve confidence.
• Watch the orchestration tax. If output piles up faster than you can review it, you are creating risk.
• Turn feedback into reusable systems. Add tests, configs, hooks, and guidelines so the same mistakes do not repeat.

Conclusion

What I liked most about Addy Osmani’s article is that it makes agentic engineering feel practical, not mystical.

The best engineers in this new world will not be the people who blindly generate the most code. They will be the people who think clearly, prompt carefully, verify habitually, and know what they are willing to put their name on.

Agents make it easier to produce. But engineering has always been about more than production.

It is about judgement. And in the agentic era, judgement matters more than ever.

📚 Further Reading & Related Topics
If you’re exploring AI agents, these related articles will provide deeper insights:

• Unlocking AI Driven Coding With Agentic Mode in Cursor IDE : Explores how agentic workflows are changing software development inside modern AI coding tools, making it highly relevant to understanding why AI agents matter.

• Decoding Developer Skepticism: Can LLMs One Shot Apps? : Looks at the practical limits and promise of LLM based development, which complements a discussion on the current capabilities of AI agents.

• Mastering ChatGPT Prompt Frameworks: A Comprehensive Guide : AI agents depend heavily on effective prompting and task framing, so this guide helps readers understand the foundations behind better agent behavior.