Pure Agent Application
An application implemented with no executable code —
only agent-readable instructions: a SKILL.md plus
supporting markdown/YAML (for example a library.yaml
reference file and a cookbook/ of named workflows). The
runtime is the agent: it reads the instructions and
performs the work directly, so "the application is the skill." An entire
application is encoded into a single skill/prompt, and an agent can run
the whole workflow or chain individual pieces of it. The same instinct
appears one altitude up as a library without code (e.g.
whenwords: a SPEC.md + tests.yaml
from which an agent regenerates the .py), the difference
being that a pure-agent app skips code entirely rather than regenerating
it. Because the whole app is plain English describing what to do and
when, it is legible to humans and agents alike — the source doubles as
documentation.
Claims
- An entire application can be encoded as a single skill/prompt with no executable code — the agent reads the instructions and is the runtime. observation — an emerging paradigm ("the application is the skill"), factual for now rather than a durable law: it holds while agents are capable enough to execute the instructions reliably.
- Keep the source in plain English — a skill file plus a cookbook of named workflows that say when to use each — so it is great for humans and agents both. best practice — context: agent-first tools where transparency and reuse matter; plain-English workflows are simultaneously the docs and the agent's instructions.
- Organize the skill as a cookbook: individual agentic workflows keyed by command name that the skill routes between, so an agent (or a human) can run one or chain several. best practice — context: a skill hosting multiple use-cases; separating per-command cookbook entries keeps routing legible and lets an agent execute the whole flow end-to-end.
- When agents are reliable enough, the durable artifact is the instruction (skill/spec) and code becomes optional or regenerable. best practice — context: contingent on agent reliability for the domain; demonstrated at small scale, and the same bet has failed at large scale (see the no-code C-compiler attempt in Spec-Driven Development).
Related
- Agentic Distribution — the
library meta-skill is a pure-agent app (
SKILL.md+library.yaml), which is what lets an agent run its entire add/use/push workflow. - Spec-Driven Development — the sibling "share the definition, not the code" bet; SDD regenerates code from a spec, a pure-agent app skips code entirely.
- Agentic Simplicity — no code is the simplest possible substrate; the agent is the only moving part.
- Agent-Computer Interface (ACI) — the skill + cookbook is the agent's interface to the app's capabilities.
- Reusable Workflow Library — a cookbook of named, self-describing workflows overlaps the loop-library anatomy.
- Distillate: The Library Meta-Skill: How I Distribute Private Skills, Agents and Prompts.
- Distillate: Learnings
from a No-Code Library: Keeping the Spec-Driven Development Triangle in
Sync — the library-without-code (
whenwords) is the same idea one altitude up.