Skip to content
Back to search

ai-devkit

Make AI coding agents follow a repeatable engineering workflow with memory, verification, skills, and multi-agent setup

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today

Check it deeper on your machine

It has changed since its scan on 14 Nov 2026. Its scripts were only partly scanned.

As a Claude Code plugin, install it and then ask Claude Code:

/plugin marketplace add keithmackay/mackayi/plugin install scanskillsafety@mackayiDo a deep scan of https://github.com/codeaholicguy/ai-devkit with scanskillsafety

Or from a terminal, clone it and run it:

git clone https://github.com/keithmackay/scanskillsafety-skill ~/.claude/skills/scanskillsafetynode ~/.claude/skills/scanskillsafety/cli.cjs --deep 'https://github.com/codeaholicguy/ai-devkit'

It checks the exact commit: every file, its packages against OSV (api.osv.dev), how it compares with this page's scan (findsafeskills.com receives the repository's address), and, if you agree, Claude reading every file with your own Claude subscription. It never runs the code.

Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/codeaholicguy--ai-devkit/badge.svg)](/listings/codeaholicguy--ai-devkit)

HTML

<a href="/listings/codeaholicguy--ai-devkit"><img src="/api/listings/codeaholicguy--ai-devkit/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

.claude-plugin/plugin.json · Manifest · 23 lines
  1. {
  2. "name": "ai-devkit",
  3. "version": "0.76.1",
  4. "description": "Make AI coding agents follow a repeatable engineering workflow with memory, verification, skills, and multi-agent setup",
  5. "author": {
  6. "name": "Hoang Nguyen",
  7. "email": "hoang@codeaholicguy.com"
  8. },
  9. "homepage": "https://ai-devkit.com/",
  10. "repository": "https://github.com/codeaholicguy/ai-devkit",
  11. "license": "Apache-2.0",
  12. "keywords": [
  13. "ai",
  14. "development",
  15. "sdlc",
  16. "workflow",
  17. "memory",
  18. "skills",
  19. "testing",
  20. "code-review",
  21. "debugging"
  22. ]
  23. }
README.md · README · 278 lines
  1. # AI DevKit
  2. > English | [中文](./README-zh.md)
  3. **The control plane for AI coding agents.**
  4. ![](agent-console-showcase.jpg)
  5. AI DevKit gives Claude Code, Codex CLI, Gemini CLI, opencode, Pi, Cursor, GitHub Copilot, Devin, and other coding agents one local-first operating layer: one config, one console, local memory retrieval, cross-agent communication, and composable engineering skills led by `dev-lifecycle`.
  6. - **One config for every agent** — `.ai-devkit.json` reconciles setup across the coding tools your team uses
  7. - **One console for running sessions** — `agent console` is a live TUI dashboard for supervising local agents across providers
  8. - **Cross-agent communication** — `agent send` lets you route prompts, logs, and test output to running agents
  9. - **Memory retrieval without context bloat** — `@ai-devkit/memory` stores decisions, conventions, and fixes in local SQLite so agents search when needed instead of carrying everything in every prompt
  10. - **Composable engineering skills** — `dev-lifecycle`, `verify`, `tdd`, review, debugging, security, docs, and simplification skills combine into reliable workflows
  11. The future is many AI coding agents. AI DevKit is the layer that makes them manageable.
  12. Run machine setup once, then `init` in each project:
  13. ```bash
  14. npx ai-devkit@latest setup
  15. cd your-project
  16. npx ai-devkit@latest init
  17. ```
  18. `setup` installs built-in skills globally, session hooks, and the memory MCP wiring for detected agents.
  19. The `kiro`, `copilot`, `devin`, and `muse` targets detect `~/.kiro`, `~/.copilot`, `~/.config/devin`, and `~/.config/muse`, respectively. Copilot skills use the `github` environment and `~/.copilot/skills`; Devin and Muse use `~/.config/devin/skills` and `~/.config/muse/skills`. Kiro has no skill environment or root defined, so its target only detects the marker and reports the memory MCP skip. All four skip memory MCP wiring until a global config writer is verified.
  20. `init` writes project-local config. Your project gets:
  21. | What you need | What AI DevKit installs |
  22. |---------------|-------------------------|
  23. | One setup source | `.ai-devkit.json` for the agents and workflow you choose |
  24. | Running-agent visibility | `agent list`, `agent detail`, and `agent console` |
  25. | Addressable agents | `agent send`, `--stdin`, `--wait`, and agent groups where supported |
  26. | Retrieval-based memory | Local SQLite memory exposed through MCP and CLI, searched only when useful |
  27. | Composable senior-engineer workflow | `dev-lifecycle` plus verification, TDD, debugging, review, security, docs, and simplification skills |
  28. [![npm version](https://img.shields.io/npm/v/ai-devkit.svg)](https://www.npmjs.com/package/ai-devkit)
  29. [![npm downloads](https://img.shields.io/npm/dt/ai-devkit.svg)](https://www.npmjs.com/package/ai-devkit)
  30. [![GitHub stars](https://img.shields.io/github/stars/Codeaholicguy/ai-devkit.svg?style=social)](https://github.com/Codeaholicguy/ai-devkit)
  31. [![License: Apache 2.0](https://img.shields.io/badge/License-Apache_2.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
  32. ## Who this is for
  33. Developers whose AI coding setup has grown from one assistant into a small, messy team of agents:
  34. - multiple terminals with no shared control surface
  35. - separate `CLAUDE.md` / `.cursor/rules` / `AGENTS.md` / MCP setup per tool
  36. - no easy way to send context, logs, or follow-up work to a running agent
  37. - the agent forgetting yesterday's conventions
  38. - "I've successfully implemented the feature" with a red build
  39. - the agent diving into code without a plan and producing the wrong thing
  40. Before AI DevKit, your agents are powerful but scattered. After AI DevKit, they have shared setup, a control surface, searchable memory, communication paths, and reusable skills that travel with your repo without bloating every prompt.
  41. | Without AI DevKit | With AI DevKit |
  42. |-------------------|----------------|
  43. | You manage agents as isolated terminal tabs | You supervise them from `ai-devkit agent console` |
  44. | You hand-maintain every agent setup | One config reconciles agent files, skills, and MCP setup |
  45. | You copy logs and context between sessions | `agent send` routes prompts and stdin to running agents |
  46. | You repeat project rules in every chat | Agents retrieve relevant memory and docs only when useful |
  47. | The agent jumps from prompt to code | `dev-lifecycle` guides requirements, design, planning, implementation, testing, and review |
  48. | "Done" means the agent stopped editing | "Done" requires fresh verification output |
  49. ## Start in 30 seconds
  50. ```bash
  51. npx ai-devkit@latest setup
  52. cd your-project
  53. npx ai-devkit@latest init
  54. ```
  55. Run `setup` once per machine, then `init` per project. Pick your agents, install the control-plane pieces you need, and give every tool the same operating model. Re-run `init` whenever your agent list or workflow changes.
  56. Multi-agent orchestration (lead plus workers): **[docs guide](https://ai-devkit.com/docs/17-multi-agent-orchestration/)**.
  57. Here's what lands in your repo:
  58. ```
  59. your-project/
  60. ├── .ai-devkit.json # single source of truth (re-run init anytime)
  61. ├── .claude/ # or .cursor/, .codex/, etc. per agent you picked
  62. │ ├── skills/ # dev-lifecycle, verify, memory, tdd, ...
  63. │ └── … # Claude: project MCP in `.mcp.json`; memory MCP wired globally by `setup`
  64. └── docs/ai/
  65. ├── requirements/ # phase 1 — what to build, why
  66. ├── design/ # phase 2 — how it'll be built
  67. ├── planning/ # phase 3 — task-by-task plan
  68. ├── implementation/ # phase 4 — execution notes
  69. └── testing/ # phase 5 — coverage strategy
  70. ```
  71. ## Operate agents like infrastructure
  72. AI DevKit ships an agent control plane for everyday multi-agent work:
  73. ```bash
  74. # List running sessions across providers
  75. ai-devkit agent list
  76. # Open the live terminal UI
  77. ai-devkit agent console
  78. # Send a prompt to a running session and wait for the response
  79. ai-devkit agent send "run the tests and report back" --id <agent-name> --wait
  80. # Pipe multi-line output into a running session
  81. npm test 2>&1 | ai-devkit agent send --id <agent-name> --stdin
  82. # Send a prompt to a saved group of agents
  83. ai-devkit agent send "review this branch for release risk" --group reviewers
  84. # Pipe a session through Telegram — operate your agent from your phone
  85. ai-devkit channel start telegram --agent <agent-name> --daemon
  86. ```
  87. Use this when work spans long-running agents, multiple providers, scheduled checks, review loops, or remote control from another channel.
  88. ## Add memory without bloating context
  89. AI DevKit memory is local SQLite knowledge for project decisions, coding conventions, and reusable fixes. Agents retrieve it when a task needs context instead of carrying every fact in every prompt.
  90. ```bash
  91. # Store a reusable project convention
  92. ai-devkit memory store \
  93. --title "API handlers return DTOs" \
  94. --content "REST handlers should return response DTOs instead of domain entities." \
  95. --tags "api,backend" \
  96. --scope "repo:codeaholicguy/ai-devkit"
  97. # Search before related work
  98. ai-devkit memory search --query "API response convention"
  99. ```
  100. ## Compose engineering workflows with skills
  101. The control plane is useful on its own. For larger or riskier changes, AI DevKit also installs composable skills that make agents behave more like an engineering team.
  102. `dev-lifecycle` is the anchor skill. It guides the agent through requirements, design, planning, implementation, testing, and review. Other skills plug into that flow:
  103. - `memory` retrieves relevant project knowledge without stuffing all context into the session
  104. - `verify` blocks completion claims without fresh test or build evidence
  105. - `tdd` pushes test-first implementation when behavior changes
  106. - `dev-debug` keeps debugging reproducible instead of guess-and-patch
  107. - `security-review`, `document-code`, and `dev-simplify` add focused review passes when the task needs them
  108. ### Get the full engineering workflow stack
  109. Save [`templates/senior-engineer.yaml`](./templates/senior-engineer.yaml) locally and run:
  110. ```bash
  111. ai-devkit init --template ./senior-engineer.yaml
  112. ```
  113. Bundles the built-in skills with curated additions from Anthropic, Vercel, and others: TDD, frontend design, webapp testing, doc co-authoring, React best practices, security review, and more.
  114. ## A feature, end-to-end
  115. ```
  116. You: Use the dev-lifecycle skill to start requirements for OAuth login with Google
  117. Agent: Searches memory for prior auth conventions. Asks clarifying
  118. questions about scope, users, success criteria. Drafts
  119. docs/ai/{requirements,design,planning}/feature-oauth-login.md
  120. in a feature worktree. Stops before coding.
  121. You: Ask for a design review of feature-oauth-login
  122. Agent: Audits the design doc against the requirements. Flags gaps,
  123. proposes fixes — before any code gets written.
  124. You: Ask it to execute the implementation plan
  125. Agent: Works the planning doc task-by-task. Updates progress after
  126. each task. The `verify` skill blocks a task from being
  127. marked done without fresh test/build output.
  128. You: Ask for a code review
  129. Agent: Audits the diff against the design doc — scope creep,
  130. missing tests, edge cases the requirements named —
  131. before you push.
  132. ```
  133. ## What changes in agent behavior
  134. The flow above is powered by **28 built-in skills** (installed globally by `setup`), including these core workflow skills:
  135. | Failure mode | AI DevKit behavior |
  136. |--------------|--------------------|
  137. | Agent starts coding too early | `dev-lifecycle` forces requirements, design, planning, implementation, tests, and review |
  138. | Agent says "done" without proof | `verify` blocks completion claims without fresh test/build evidence |
  139. | Agent commits unrelated local changes | `dev-commit` checks diffs, stages explicit paths, validates, and reports the SHA/status |
  140. | Agent forgets project decisions | `memory` gives it a local, searchable knowledge base across sessions and projects |
  141. | New behavior ships without tests | `tdd` pushes test-first implementation |
  142. | Debugging becomes guess-and-patch | `dev-debug` makes it reproduce, hypothesize, fix, and verify |
  143. | Existing code is opaque | `document-code` maps entry points, dependencies, and behavior |
  144. | Implementation gets bloated | `dev-simplify` reduces complexity before code ships |
  145. | Unit tests pass but the flow is broken | `dev-smoke` smoke-tests the affected flows end to end in a sandbox |
  146. | The same mistake keeps coming back | `dev-retro` turns friction into tests, checks, or skill fixes |
  147. | Documentation is hard to follow | `document-code` maps code; add community `technical-writer` via `skill add` if needed |
  148. Need more? `ai-devkit skill add <registry> <skill>` pulls from 30+ publishers — Anthropic, Vercel, Supabase, Microsoft, Google. See the full built-in list in [Skills docs](https://ai-devkit.com/docs/7-skills/).
  149. ## Works across coding agents
  150. One `.ai-devkit.json` configures all of them. Add a new agent to your team without rewriting your rules.
  151. | Agent / environment | Project `init` setup | `agent start` / `send` control plane |
  152. |-------|-------|----------------|
  153. | [Claude Code](https://www.anthropic.com/claude-code) | yes | yes (`claude`) |
  154. | [Gemini CLI](https://github.com/google-gemini/gemini-cli) | yes | yes (`gemini_cli`) |
  155. | [Codex CLI](https://github.com/openai/codex) | yes | yes (`codex`) |
  156. | [Grok Build CLI](https://x.ai/cli) | yes | yes (`grok_cli`) |
  157. | [opencode](https://opencode.ai/) | yes | yes (`opencode`) |
  158. | [Pi](https://pi.dev) | yes | yes (`pi`) |
  159. | [GitHub Copilot](https://github.com/features/copilot) | yes | yes (`copilot`) |
  160. | [Kiro CLI](https://kiro.dev/cli/) | yes | yes (`kiro`) |
  161. | [Devin](https://devin.ai/) | yes | yes (`devin`) |
  162. | [Muse Code](https://dev.meta.ai/products/muse-code/) | yes | yes (`muse`) |
  163. | [Antigravity CLI](https://antigravity.google/) | yes | yes (`antigravity_cli`) |
  164. | [Cursor](https://cursor.sh/) | yes | — |
  165. | [Junie](https://www.jetbrains.com/junie/) | yes | setup/skills only |
  166. | [Cline](https://cline.bot/) | yes | setup/skills only |
  167. | [Antigravity IDE](https://antigravity.google/) | yes | setup/skills only |
  168. | [Amp](https://ampcode.com/) | yes | setup/skills only |
  169. | [Kilo Code](https://github.com/Kilo-Org/kilocode) | yes | setup/skills only |
  170. | [Roo Code](https://roocode.com/) | testing | setup/skills only |
  171. **Setup** — `ai-devkit setup` (machine) plus `ai-devkit init` (project) writes each agent's config (rules, MCP, skills).
  172. **Control plane** — `agent list`, `agent send`, and managed `agent start` target tmux-backed CLI sessions on **macOS/Linux** (experimental console; requires tmux). Use [channels](https://ai-devkit.com/docs/12-channel/) to message a running agent from Telegram or Slack. Not supported on Windows console.
  173. ## How is this different from `CLAUDE.md`, `.cursor/rules`, or `AGENTS.md`?
  174. Those files are static instructions the agent re-reads. AI DevKit gives agents an **operating layer**: generated setup, a control console, cross-agent messaging, local searchable memory, phase docs, skills loaded on demand, and verification gates. The rules still matter, but AI DevKit makes them operational across tools.
  175. | Static rules files | AI DevKit |
  176. |--------------------|-----------|
  177. | Tell one agent what you prefer | Reconciles setup across supported agents |
  178. | Do not show what is running | Lists, inspects, and controls live sessions |
  179. | Cannot send work between sessions | Routes prompts, stdin, and channel messages to agents |
  180. | Depend on the agent remembering every rule | Stores and searches reusable project knowledge |
  181. | Cannot prove a task is complete | Requires fresh command output before completion claims |
  182. ## What this isn't
  183. - **Not a smarter LLM.** Bad models stay bad — this raises the floor on process, not on raw capability.
  184. - **Not a replacement for Claude Code, Codex, Cursor, Gemini CLI, or opencode.** AI DevKit configures, supervises, and coordinates the agents you already use.
  185. - **Not a magic "write the feature for me" button.** You still review the requirements doc, accept the design, and read the diff. The workflow makes that review possible because you have artifacts to point at instead of only chat scrollback.
  186. - **Not a hosted service.** Apache-2.0-licensed, runs locally, no telemetry. Memory is a SQLite file on your disk. The control plane detects CLI sessions, types into tmux panes, and reads session files — it does not run a remote cloud agent for you.
  187. ## Documentation & community
  188. - Full guides, workflow patterns, skill authoring → **[ai-devkit.com/docs](https://ai-devkit.com/docs/)**
  189. - Release notes → **[CHANGELOG.md](./CHANGELOG.md)**
  190. - Contributing → open an issue or PR on **[GitHub](https://github.com/Codeaholicguy/ai-devkit)**
  191. ```bash
  192. git clone https://github.com/Codeaholicguy/ai-devkit.git
  193. cd ai-devkit && npm install && npm run build
  194. ```
  195. ## License
  196. Apache License 2.0
  197. ## Star History
  198. <a href="https://www.star-history.com/?repos=codeaholicguy%2Fai-devkit&type=date&legend=top-left">
  199. <picture>
  200. <source media="(prefers-color-scheme: dark)" srcset="https://api.star-history.com/chart?repos=codeaholicguy/ai-devkit&type=date&theme=dark&legend=top-left" />
  201. <source media="(prefers-color-scheme: light)" srcset="https://api.star-history.com/chart?repos=codeaholicguy/ai-devkit&type=date&legend=top-left" />
  202. <img alt="Star History Chart" src="https://api.star-history.com/chart?repos=codeaholicguy/ai-devkit&type=date&legend=top-left" />
  203. </picture>
  204. </a>

Version history

  • v0.76.111/14/2026

  • v0.75.011/13/2026

  • v0.73.111/11/2026

  • v0.72.011/5/2026

  • v0.71.010/24/2026

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.