AI Skills

Agent instructions should be reusable delivery infrastructure, not prompt history.

AI Skills is an open-source skill package for spec-driven development with reusable agent workflows for writing specs, planning implementation, executing scoped tickets, and reviewing delivery against approved expectations.

Docs Repository

Enterprise pressure

Why it matters

AI-assisted delivery breaks when every agent run depends on the current prompt, the current memory, and the current level of human patience. Specs drift, tickets leave room for interpretation, implementation agents invent missing behavior, and review quality depends on whoever still has time to look closely.

Product answer

What changes

AI Skills packages the delivery method itself. The repository defines focused skills for spec architecture, implementation planning, ticket execution, and implementation review so agents can create stronger specs, split work into executable slices, implement inside strict boundaries, and route findings back to the right source of truth.

Operating model

How the model holds

Human intent and project context enter the spec architect; approved specs feed the planner; scoped tickets drive implementation agents; implementation review checks the delivered paths and routes findings back to specs, plans, or tickets.

skills pipeline AI Skills

spec knowns intent, context, constraints

plan waves dependencies, scope, tickets

build tickets tests, boundaries, evidence

review proof drift, gaps, acceptance

human intent agent skills quality gates feedback loop

Decision path

AI Skills exists because prompt craft is not enough for serious AI-assisted delivery.

If an organization wants agents to create specs, plan work, implement tickets, and review results, the operating model cannot live only in a conversation. It has to become explicit, reusable, reviewable, and close to the project.

The repository turns my spec-driven development workflow into executable agent guidance. One skill shapes the spec and readiness gates. One turns approved specs into implementation waves and tickets. One implements a single scoped ticket. One reviews the delivered system against the approved expectations.

That is the important move: the human does not repeat the same review thinking manually forever. The human improves the system that gives AI context, boundaries, checks, and feedback loops.

Enterprise relation

Where this connects to enterprise pressure.

Review judgment becomes reusable infrastructure instead of disappearing into chat history or one-off pull request comments.

Teams can standardize how AI agents receive context, respect scope, check dependencies, and produce acceptance evidence.

Quality gates can run repeatedly and improve over time, reducing the long-term cost of planning, implementation review, and audit preparation.

Spec, plan, ticket, and review artifacts create a project knowledge base that is useful for humans and executable by agents.

Capabilities

AI Skills turns pressure into an operating model.

Spec architect skill for creating, repairing, reviewing, and approving implementation-ready specs

Implementation planner skill for turning approved specs into dependency-ordered waves and AFK tickets

Ticket implementation skill for executing one scoped ticket without inventing behavior or expanding write scope

Implementation review skill for checking solution paths against approved specs, plans, tests, and evidence

Human-facing docs plus executable SKILL.md files that keep agent guidance and project knowledge reusable

Installable package through the open skills ecosystem with `npx skills add sebastianwessel/skills`

Enterprise use cases

Where decision makers should care.

Turn recurring review questions into reusable skills instead of repeating them manually in every prompt

Build a spec-driven workflow where specs, plans, tickets, and reviews have explicit quality gates

Let multiple AI agents work in parallel without drifting away from approved contracts and expectations

Reduce manual planning and review load while improving traceability, testability, and delivery evidence

Capture project and architecture knowledge in a form humans can inspect and agents can execute

Links

Docs Docs Repository Repository