What I'm Learning from Addy Osmani's Agent Skills
I've been spending some time experimenting with Addy Osmani's Agent Skills recently.
At first, I was drawn in by the individual skills. Since I spend a lot of time thinking about software architecture and AI, anything that promises to improve how AI agents build software grabs my attention.
But as I explored the framework, I could really see the most interesting part isn’t any single skill.
It’s actually the workflow.
The main idea is simple:
AI coding agents naturally optimise for the shortest path.
But the shortest path often skips the things that help teams build reliable software, like specifications, planning, testing, review, and validation.
Addy’s Agent Skills takes a different approach.
Instead of just using AI as a code generator, it tries to build engineering discipline into a structured software delivery process.
The framework is organised around six phases:
Define → Plan → Build → Verify → Review → Ship
I’m still early in exploring this, so these are just my first impressions. What stands out to me is how each phase is supported by specialist skills that encourage certain engineering habits.
The Skills With the Software Lifecycle
Define: Understanding Before Implementing
The Define phase brings together skills that help make things clearer and reduce confusion before any coding begins.
- Interview Me - Applies structured questioning to uncover requirements and clarify intent.
- Idea Refine - Applies divergent and convergent thinking to transform vague concepts toward clearer solutions.
- Spec Driven Development - Produces a specification covering objectives, structure, testing expectations, and boundaries.
What really stands out to me here is the focus on thinking things through before building.
One thing I’ve learned over and over is that unclear requirements don’t magically get clearer once you start coding. They just get more costly.
My favourite skill: Spec Driven Development
The more I use AI, the more I see how important good specifications are. AI can speed things up, but only if it’s headed in the right direction.
Plan: Turning Intent Into Execution
Once you know what you want to do, the framework moves on to planning.
Here, the focus is on making things less complex by breaking them down.
- Planning and Task Breakdown - Decomposes specifications into small, verifiable tasks with acceptance criteria and execution order.
At the heart of this phase is a simple but powerful idea:
Complex systems get easier to handle when you break them into smaller, understandable parts.
Good planning doesn't eliminate complexity. It organises that complexity.
My favourite skill: Planning and Task Breakdown
As software builders, we’re always breaking down problems. I think this is one of the most valuable things we do, whether we’re designing systems, teams, or delivery plans.
Build: Incremental Delivery Over Big Bang Development
The Build phase includes many of the framework’s most specialized engineering skills.
Instead of just pushing out code quickly, the focus here is on building in small steps, checking your work often, and making decisions based on real evidence.
- Incremental Implementation - Delivers software in thin, rollback-friendly vertical slices.
- Test Driven Development - Reinforces Red-Green-Refactor and disciplined testing practices.
- Context Engineering - Loads only the information required for the current task, treating context as a finite resource.
- Source Driven Development - Grounds decisions in official documentation and verifiable sources.
- Doubt Driven Development - Applies adversarial thinking to scrutinise assumptions and reduce risk.
- Frontend UI Engineering - Focuses on component architecture, accessibility, responsive design, and user experience.
- API and Interface Design - Encourages contract-first design and well-defined interfaces.
This phase really matches up with a lot of the engineering practices I’ve supported for years.
Small increments.
Fast feedback.
Clear boundaries.
Continuous validation.
My favourite skill: Doubt Driven Development
This one really caught my eye. Engineering is full of assumptions, and AI can make those assumptions seem even more convincing. Adding a bit of skepticism to the process feels like a surprisingly strong idea.
Verify: Evidence Over Confidence
The Verify phase is all about proving that software works, not just assuming it does.
In a world where AI helps us code, I think this difference matters more than ever.
- Browser Testing with DevTools - Uses runtime evidence such as DOM inspection, console output, network activity, and profiling information.
- Debugging and Error Recovery - Applies a systematic process for reproducing, localising, resolving, and stopping issues.
One phrase from the framework stood out to me:
Tests are proof.
As it gets easier to generate code, checking that it actually works becomes even more valuable.
Confidence isn't evidence. Running systems are.
My favourite skill: Debugging and Error Recovery
I’ve always thought debugging is one of the most underrated engineering skills. Being able to find the real cause of a problem, instead of just guessing, is still really important no matter how the code is written.
Review: Engineering Discipline at Scale
The Review phase adds structured quality checks before software moves ahead.
It’s about making sure quality keeps up with speed.
- Code Review and Quality - Applies a structured, multi-axis review process with severity assessments.
- Code Simplification - Reduces unnecessary complexity whilst preserving existing behaviour.
- Security and Hardening - Introduces secure development practices and OWASP-focused thinking.
- Performance Optimisation - Promotes measurement and profiling before optimisation work begins.
What’s interesting here is that AI doesn’t take away the need for engineering judgment. If anything, it makes it even more important.
As implementation becomes easier, evaluating implementation becomes more important.
My favourite skill: Code Simplification
Over the years, I’ve learned that complexity adds up. The best code isn’t usually the cleverest solution - it’s the one that’s easiest to understand six months down the line.
Ship: Thinking Beyond the Code
The Ship phase is where the framework goes beyond development and into operations.
Software isn’t successful just because it got merged. It’s successful because it can run safely in production.
- Git Workflow and Versioning - Encourages trunk-based development and small, atomic changes.
- CI/CD and Automation - Uses automated pipelines and quality gates to reduce delivery risk.
- Deprecation and Migration - Treats obsolete code as a liability and manages its removal.
- Documentation and ADRs - Captures architectural decisions and the reasoning behind them.
- Observability and Instrumentation - Introduces logging, metrics, tracing, and operational visibility.
- Shipping and Launch - Supports staged rollout, monitoring, and rollback strategies.
One phrase associated with this phase caught my attention:
Faster is safer.
Not because speed itself reduces risk, but because small, observable, reversible changes are usually less risky than large releases.
My favourite skill: Observability and Instrumentation
You can’t improve what you can’t see. Modern systems need visibility, not guesswork.
My Initial Takeaway
The more I look into Addy’s Agent Skills, the more I can see that the real benefit isn’t the AI-generated code.
It’s about building engineering discipline into repeatable workflows.
Every phase seems designed to protect against a common failure mode:
- Define protects against ambiguity.
- Plan protects against overwhelming complexity.
- Build protects against risky implementation approaches.
- Verify protects against false confidence.
- Review protects against technical debt.
- Ship protects against operational risk.
Whether you’re using AI, working with a team, or building software on your own, these are really valuable principles.
I’m still trying out the framework and figuring out my thoughts, but these are my first impressions.
I’ll definitely revisit some of these skills in future posts, since a few of them deserve a much deeper look.