Five years ago, the most valuable developer on your team wrote elegant code. Clean architecture. Clever algorithms. The person who could implement any feature from scratch commanded top dollar.
That skill is becoming a commodity.
The new scarcity isn't code-writing. It's skill design—the ability to create atomic capabilities that AI agents can compose into workflows humans never imagined.
What "skills" means in agent native development
Skills are the fundamental building blocks of agent native apps. They're the atomic actions your system can perform—smaller than features, bigger than functions.
Think of traditional features as bundled products. A "publish article" feature might format content, set a publication date, generate social posts, and send to subscribers. Convenient for users who want the whole package.
Useless for agents who need the pieces.
Skills unbundle these actions. Format content is one skill. Set publication date is another. Generate social posts is a third. Each skill does one thing. Agents compose them into workflows.
Dan Shipper's team at Every builds Proof with this architecture. Every capability in their markdown editor exists as a skill. Users access skills through the interface. Agents access the same skills programmatically. The app tracks human versus AI contributions because both work through identical underlying capabilities.
Why skill design is harder than it looks
Designing good skills requires thinking at two levels simultaneously.
Human ergonomics: How will users trigger this skill? What interface makes it intuitive? How does it fit existing mental models?
Agent ergonomics: How will agents compose this skill? What inputs and outputs enable chaining? How granular is granular enough?
These requirements often conflict.
Humans want bundled convenience. Agents want atomic composability. Finding the right skill boundaries means satisfying both constraints—or exposing multiple interfaces to the same underlying capability.
The best skill designers treat this like API design for a future they can't predict. The agents consuming these skills will be more capable next year than they are today. Skills designed with rigid assumptions about agent limitations become bottlenecks as models improve.
The granularity principle in practice
Paula's team at Portola ships AI-generated features to hundreds of thousands of users. Non-engineers open production pull requests. This isn't magic—it's architecture.
Their system exposes granular skills at every level:
- PR creation is a skill
- Code review is a skill
- Addressing review feedback is a skill
- Merging is a skill
Agents orchestrate these skills in automated loops. A PR Shepherd agent monitors open pull requests, generates responses to feedback, and handles routine follow-ups. Engineers review the results instead of doing the work.
This only functions because each skill is atomic enough for agents to use independently. Bundle "handle pull request" into one monolithic capability and the whole system collapses.
Why prompt engineering matters as much as skill design
Skills are one half of the equation. Prompts are the other.
When agents consume your skills, the prompts guiding those agents determine everything—which skills get called, in what order, with what inputs. A brilliant skill paired with a poor prompt produces garbage. A mediocre skill with excellent prompting sometimes outperforms.
Ryan Carson's team at Untangle runs automated product development loops. Cron jobs analyze app data daily. Agents generate improvement recommendations. More agents create implementation plans and execute them with quality gates.
The whole system depends on two things: granular skills and precise prompts. Skills provide the capabilities. Prompts provide the orchestration logic. Both require the same design rigor.
The compound engineering connection
Kieran Klassen's compound engineering workflow systematizes skill development:
Planning phase: Deep context gathering. What skills exist? What's missing? What boundaries make sense?
Working phase: Implementation with proper grounding. Build the skill with clear inputs, outputs, and error handling.
Review phase: Automated checks for security, performance, and composability. Can other skills chain with this one?
Compounding phase: Documentation and institutional knowledge. Record what worked, what failed, and why.
This loop creates reusable skill libraries that compound over time. Each skill added increases the space of possible compositions exponentially.
What this means for your career
If you're a developer, the question isn't whether to learn skill design. It's how fast.
Traditional code-writing remains valuable—someone has to implement the skills. But the strategic decisions happen at the skill level. What capabilities should exist? How should they compose? What granularity enables the workflows of the future?
These questions are the new core competencies.
The developers who master skill design and prompt engineering will architect systems that get more powerful automatically. Every model improvement enhances their work. Every new agent capability expands what their skills can do.
The developers who focus only on implementation will find their work increasingly automated—by the very skills their colleagues designed.
The skills audit
Look at your current projects. Ask these questions:
Skill inventory: What atomic capabilities does your system expose? Can you list them?
Granularity check: Are your skills truly atomic, or are they bundled features in disguise?
Composition check: Can existing skills chain together in ways you didn't design for?
Documentation check: Would a new agent (or new team member) understand how to use your skills?
Prompt check: Are the prompts orchestrating your skills as carefully designed as the skills themselves?
The answers reveal how agent-ready your system actually is.
The teams building skill libraries today will have compounding advantages as AI capabilities explode. The teams who wait will find themselves implementing someone else's skill designs—until that work gets automated too.