kiko-skills plugin
Four skills take an idea to an approved spec and reviewed code, with state kept in the project .kiko folder
- 167 ★ on the repository
- Last commit
- MIT
Extended access
Why this level
- The `implement` skill gives subagents the editing and review of project code, and `setup-kiko` creates files at the root
Install
- Works in
Manual install
npx skills add Levix0501/kiko-skillsAfter installing, call `/setup-kiko` at the project root.
Access and checks
How we reviewExtended accessThe tool runs code or makes network calls and only reads external data.
- The `implement` skill gives subagents the editing and review of project code, and `setup-kiko` creates files at the root
This is third-party code. Review the repository files before installing.
What it does
kiko-skills installs with `npx skills add Levix0501/kiko-skills` and gives four steps called in turn inside a project. `/setup-kiko` creates the `.kiko` working folder once, with `TODO.md`, `docs/`, `.implement/` and `.gitignore`. The `scripts/init-kiko` script is safe to repeat: it fills in what is missing and keeps what exists. If the project root is not inside a git repository, the agent warns about it and does not run `git init` itself. `/kick-off <idea>` cuts a request into vertical outcomes, each verifiable on its own and passing through every layer it touches. Outcomes get `P0`, `P1` and `P2` importance marks and dependencies, land in `TODO.md`, then the agent picks what to build next and interviews you until every decision is settled. `/create-spec` turns the decisions into a build-ready spec that a fresh context can implement and verify. `/implement .kiko/docs/<spec-folder>` builds from the spec: the controller writes nothing itself and hands roles to subagents for implementation and review, with a loop from implementation to review and fix and then completion. Each skill checks the working folder with the `check-kiko` script and asks you to run `setup-kiko` if it is missing.
Who it is for. Developers who want to take a feature in Claude Code or Codex in order: outcomes, decisions, spec, implementation with review.
Good fit when
- A vague idea becomes a list of outcomes with `P0` to `P2` marks and dependencies through `/kick-off`
- Decisions have to be frozen into a spec from which a fresh context can do and verify the work
- Implementation goes to subagents with separate implement and review roles while the controller writes no code
- Feature state lives in `.kiko/docs/<folder>` with `decisions.md`, `facts.md` and `spec.md` side by side
Not a fit when
- The task is a single edit: the full path from outcomes to review is overkill
- You need a ready method with templates for a specific stack: the skills are general and language-independent
- You need documentation with examples: the README is a short quick start and details live in the skill files
Example request
/kick-off split CSV report export into outcomes and prepare it for a specLimitations
The README fits on one screen: installation and four commands, with details in the `SKILL.md` files and `references/` notes. The `setup-kiko`, `kick-off` and `implement` skills are marked `disable-model-invocation`, so the agent does not start them itself and only the user does. Before work each skill calls `scripts/check-kiko` and on exit code 3 asks you to run `setup-kiko` in the project root. If a spec already exists, `create-spec` reports it and stops with no overwriting. `implement` needs an agent with subagent support.
How to disable. Delete the `setup-kiko`, `kick-off`, `create-spec` and `implement` skill folders from the agent skills directory. The `.kiko` working folder stays in the project and can be deleted by hand along with accumulated specs.
FAQ
How do I install kiko-skills?
Run `npx skills add Levix0501/kiko-skills`, then call `/setup-kiko` in the project. The skills are also available as a Claude Code plugin, with the manifest in `.claude-plugin/plugin.json`.
What does setup-kiko create?
A `.kiko` folder with `TODO.md`, `docs/`, `.implement/` and `.gitignore`. Re-running is safe: missing parts are filled in, and existing files and custom ignore content stay.
In what order should I call the skills?
`/setup-kiko` once, then `/kick-off <idea>`, `/create-spec` and `/implement .kiko/docs/<folder>`. The author notes that each step hands off to the next and you can join anywhere.
What does kick-off do?
Cuts the request together with the contents of `TODO.md` into outcomes that are each verifiable on their own, sets `P0`, `P1` and `P2` marks and dependencies, then interviews you until every question is settled.
Who writes the code in implement?
Subagents. The controller does not implement, review or fix anything itself and hands out fresh roles for implementation and review in a chain.
Discussion
No questions or reviews yet.
Related
PluginsKiro-style spec-driven development: a skill set that takes work from idea through requirements and design to autonomous implementation
Two skills for spec-driven development: /spec asks questions and saves a document to specs/, /spec-impl implements an approved spec step by step
GitHub toolkit for spec-driven development: the specify CLI adds agent commands and skills to a project, from principles to implementation
Nine JS Mastery skills take a change through phases: from idea and spec to verification, tests, release texts and a docs sync
Orchestrator skill: from an idea the agent writes requirements and a spec, splits work into tasks, builds the project, checks it
skill-kit builds agent skills as typed TypeScript state machines with schema-checked answers and a build into a SKILL.md directory
Comparison with similar tools
Cards that share the main search query, and how they differ.
| Tool | Official | Repository stars | Main difference |
|---|---|---|---|
| kiko-skills (this card) | no | 167 | |
| Spec Kit | no | 149,633 | the GitHub toolkit with a specify CLI and spec commands, while this has four skills and a `.kiko` working folder with no separate CLI |
| Skills for real engineers by Matt Pocock | no | 322,978 | small skills for plan interviews, TDD, diagnosis and review, while this is one chain from outcomes to implementation with subagents |
README in short
The README consists of a title, a one-line description, a quick start with four commands and the MIT license. The whole workflow is described in the skills themselves: each starts by checking the `.kiko` folder and then follows the steps of its stage.