Skip to content
Back to search

ai-native-sdlc

Reusable Codex + Claude Code skill and plugin implementing Anthropic's AI-Native SDLC: Plan → Design → Build → Test → Deploy → Maintain, with human approval gates at every handoff.

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 11 Nov 2026.

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/bashebr/ai-native-sdlc 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/bashebr/ai-native-sdlc'

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/bashebr--ai-native-sdlc/badge.svg)](/listings/bashebr--ai-native-sdlc)

HTML

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

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

As a Codex skill

mkdir -p ~/.codex/skills
cp -R skills/ai-native-sdlc ~/.codex/skills/

As a Claude Code skill

mkdir -p ~/.claude/skills
cp -R skills/ai-native-sdlc ~/.claude/skills/

As a Codex plugin

Clone or copy this repo to `~/plugins/ai-native-sdlc`, then add it to your personal marketplace at `~/.agents/plugins/marketplace.json`:

{
  "name": "personal",
  "interface": {
    "displayName": "Personal"
  },
  "plugins": [
    {
      "name": "ai-native-sdlc",
      "source": {
        "source": "local",
        "path": "./plugins/ai-native-sdlc"
      },
      "policy": {
        "installation": "AVAILABLE",
        "authentication": "ON_INSTALL"
      },
      "category": "Productivity"
    }
  ]
}

For a team, publish the repo and point a marketplace at it instead.

Installing the plugin also makes the bundled skill available, so you don't need to also copy it into `~/.codex/skills` — choose one path.

Or inherit the repo directly

Fork it, keep the skill and templates, and drop in your organization's standards. The repo models the workflow it ships, so agents working inside it (via the root `AGENTS.md`) follow the same conventions.

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.

README.md · README · 319 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. # AI-Native SDLC — reusable workflow repo
  2. ![AI-Native SDLC workflow loop: Plan → Design → Build → Test → Deploy → Maintain](assets/ai-native-sdlc-banner.png)
  3. A ready-to-inherit implementation of Anthropic's [AI-Native SDLC playbook](https://claude.com/blog/the-ai-native-sdlc-playbook): give your coding agent a goal or idea, and it scaffolds and drives the project through the full lifecycle — planning, design, build, test, deploy, and maintain — with human approval gates at every handoff.
  4. This repo is three things at once:
  5. - A **Codex skill** at `skills/ai-native-sdlc/`, installable into `~/.codex/skills`.
  6. - A **Claude Code skill** — the same folder, installable into `~/.claude/skills`.
  7. - A **Codex plugin** (`.codex-plugin/plugin.json` at the repo root) that bundles the skill, so teams can publish or fork it as their workflow baseline.
  8. **Learn more:** [Phase-by-phase playbook](skills/ai-native-sdlc/references/playbook.md) · [Staged adoption guide](skills/ai-native-sdlc/references/adoption.md) · [Workflow as a directed graph](skills/ai-native-sdlc/references/graph.md) · [Agent org](skills/ai-native-sdlc/references/org.md) · [Worked example](examples/expense-tracker/)
  9. ## What this is about
  10. Writing code is no longer the bottleneck — agents produce it in hours. The bottleneck moved to the process around the code: planning, review, deployment, and governance still run at human speed and human scale. This repo reworks the SDLC so those stages keep up with the build. The loop is Plan → Design → Build → Test → Deploy → Maintain; every stage ends by committing a versioned artifact the next stage reads, human judgment concentrates at gates instead of line-by-line review, guardrails run as deterministic hooks rather than habits, and continuous evals replace stage-gate QA. The operating principle, in one sentence: the agent can do everything up to the production gate, but never crosses it.
  11. ## Graph engineering
  12. The loop is a directed graph, not a linear pipeline. Plays and artifacts are nodes, gates are human approval points, and triggers are the edges that fire the next stage: an accepted intent fires Design, an approved spec fires plan mode, a merged PR fires the pipeline, and a breached control band writes the next intent. Treating the workflow as a graph makes it automatable, parallelizable (independent branches run in separate worktrees), and auditable (node history is the record). The plays also form a separate adoption graph — start at the leaf plays (capture intent, CLAUDE.md, feedback loop, hooks, plan mode) and build outward. The machine-readable form is `skills/ai-native-sdlc/assets/workflow-graph.example.yaml`; full detail in `skills/ai-native-sdlc/references/graph.md`.
  13. ## The workflow
  14. ```
  15. Plan → Design → Build → Test → Deploy → Maintain
  16. ↑ │
  17. └────────────────── back to Plan ←─────────────┘
  18. ```
  19. Each phase ends by committing a versioned artifact; the next phase starts by
  20. reading it. The full phase → artifact → gate contract lives in
  21. `skills/ai-native-sdlc/SKILL.md` (single source of truth). The short version:
  22. **Plan** commits `intent.md`, **Design** commits `spec.md`, **Build** commits
  23. `plan.md` then code + tests, **Test** reports eval results, **Deploy** ships an
  24. authorized release, **Maintain** writes its diagnosis back as a new
  25. `intent.md`.
  26. The agent does the generation, verification, and mechanical work. Humans keep the judgment calls: the agent goes all the way to the production gate and never crosses it.
  27. **Framework mapping.** The skill is framework-neutral: Claude Code calls repository memory CLAUDE.md and keeps skills in `.claude/skills/`; Codex calls it AGENTS.md and installs skills into `~/.codex/skills/`. The templates, artifacts, and scaffold script are the same either way.
  28. ## Install
  29. ### As a Codex skill
  30. ```bash
  31. mkdir -p ~/.codex/skills
  32. cp -R skills/ai-native-sdlc ~/.codex/skills/
  33. ```
  34. ### As a Claude Code skill
  35. ```bash
  36. mkdir -p ~/.claude/skills
  37. cp -R skills/ai-native-sdlc ~/.claude/skills/
  38. ```
  39. ### As a Codex plugin
  40. Clone or copy this repo to `~/plugins/ai-native-sdlc`, then add it to your personal marketplace at `~/.agents/plugins/marketplace.json`:
  41. ```json
  42. {
  43. "name": "personal",
  44. "interface": {
  45. "displayName": "Personal"
  46. },
  47. "plugins": [
  48. {
  49. "name": "ai-native-sdlc",
  50. "source": {
  51. "source": "local",
  52. "path": "./plugins/ai-native-sdlc"
  53. },
  54. "policy": {
  55. "installation": "AVAILABLE",
  56. "authentication": "ON_INSTALL"
  57. },
  58. "category": "Productivity"
  59. }
  60. ]
  61. }
  62. ```
  63. For a team, publish the repo and point a marketplace at it instead.
  64. Installing the plugin also makes the bundled skill available, so you don't need to also copy it into `~/.codex/skills` — choose one path.
  65. ### Or inherit the repo directly
  66. Fork it, keep the skill and templates, and drop in your organization's standards. The repo models the workflow it ships, so agents working inside it (via the root `AGENTS.md`) follow the same conventions.
  67. ## Use it
  68. Start a new project:
  69. ```bash
  70. python3 skills/ai-native-sdlc/scripts/init_workflow.py my-project --name "My idea"
  71. ```
  72. Then tell your agent:
  73. > $ai-native-sdlc: I want to build an expense tracker. Start with the intent.
  74. The agent interviews you until the idea is concrete, writes `intent/intent.md`, commits it, and asks you to accept. From there it moves through spec → plan → build → test → deploy, stopping at each approval gate, and finally wires up monitoring so the loop can close back into new intents.
  75. Already have a project? Copy the templates into it:
  76. ```bash
  77. cp skills/ai-native-sdlc/assets/{intent.md,spec.md,plan.md,CLAUDE.md,REVIEW.md,bands.yaml} .
  78. cp skills/ai-native-sdlc/assets/production-gate.sh hooks/
  79. ```
  80. ## Autonomous agent org
  81. For teams that want the loop to run with less human steering, the skill can
  82. scaffold an **agent org** into any project — named roles with an org chart,
  83. peer review of every artifact, and multi-channel demand intake:
  84. ```bash
  85. python3 skills/ai-native-sdlc/scripts/init_org.py my-project
  86. ```
  87. The default org is orchestrator-led:
  88. ```text
  89. CEO (human, owner)
  90. └── orchestrator
  91. ├── product-manager
  92. ├── architect
  93. ├── senior-developer
  94. ├── security-researcher
  95. ├── reviewer
  96. └── memory-keeper
  97. ```
  98. The orchestrator routes work and runs the deterministic bounded loop;
  99. specialists consult each other through versioned `org/messages/`; the memory
  100. keeper keeps `org/memory/context.md` compact. The optional product-engineer
  101. role is disabled by default.
  102. **How a turn works.** `org_loop.py next` computes one dispatch from loop state,
  103. artifacts, reviews, and open messages. The dispatched role acts, records
  104. evidence with `advance`, and the memory digest is refreshed. `next` is
  105. deterministic; `advance` is the only state mutator. Defaults are six turns, two
  106. no-progress turns, and two review rounds. Stop reasons are `solved`,
  107. `gate_required`, `failed`, `stalled`, and `exhausted`. The loop never records an
  108. approval or crosses the human merge/release gate.
  109. ```bash
  110. python3 scripts/org_message.py send --from senior-developer --to architect \
  111. --kind question --subject "Cache boundary" --body-file /tmp/question.md
  112. python3 scripts/org_loop.py next --json
  113. python3 scripts/org_loop.py advance --role senior-developer --action implement \
  114. --result progress --artifact src/app.py --evidence .loop/tests.log
  115. python3 scripts/org_memory.py digest
  116. ```
  117. **Enable the GitHub Actions loop.**
  118. ```bash
  119. cp skills/ai-native-sdlc/assets/org-loop.yml.example .github/workflows/org-loop.yml
  120. ```
  121. Configure the `ORG_AGENT_CMD` secret. The workflow runs on manual dispatch, an
  122. issue labeled `agent-loop`, or an optional schedule; it dispatches exactly one
  123. turn and opens a PR. It needs `contents: write`, `pull-requests: write`, and
  124. `issues: read`, and never merges or releases. A manual `work_item` input must
  125. match the initialized loop state; switch work items explicitly with
  126. `org_loop.py init --work-item ... --force`.
  127. Demand enters through GitHub issues (`scripts/sync_issues.py pull`), app
  128. feedback forms, and email, all landing as versioned records in `org/intake/`.
  129. `scripts/org_status.py` keeps busy/idle state and the review queue valid
  130. against `org/org-chart.yaml`; `scripts/intake.py add|list` normalizes form and
  131. email demand.
  132. See `skills/ai-native-sdlc/references/org.md` for the full protocol.
  133. ## Examples
  134. The `examples/` folder contains a worked project — the expense-tracker idea
  135. from this README. It shows what `intent.md`, `spec.md`, `plan.md`, `CLAUDE.md`,
  136. and the workflow graph look like when filled in, and it is also a real static
  137. app (`index.html`, `app.js`, `style.css`) with expenses persisted in the
  138. browser. **Live demo:** [bashebr.github.io/ai-native-sdlc](https://bashebr.github.io/ai-native-sdlc/)
  139. — hosted on GitHub Pages from the repo's `gh-pages` branch. The folder also
  140. opens locally (`index.html`) and is Vercel-ready via `vercel.json`. Use the
  141. example as reference for tone and structure, then scaffold your own blanks
  142. with the script above.
  143. ## Customizing for your organization
  144. - **Standards as skills** — encode brand, security, UX, and compliance policies as skills so Design and Build apply them consistently.
  145. - **Hooks as red lines** — protected paths, secrets, and the release gate go in deterministic hooks, not prose. `production-gate.sh` blocks deploys without human authorization, and `scan_secrets.py` (with the `pre-commit.example` hook) blocks credentials from entering a commit; `hook-settings.example.json` shows the release-gate wiring; `managed-settings.example.json` is the regulated-enterprise starting point.
  146. - **Evals** — collect 20–50 real tasks with expected outcomes; run them in CI on every config change and after every incident (`agent-evals.yml.example`).
  147. - **Review culture** — `REVIEW.md` sets the passes (bugs, security, compliance), the evidence requirement, and the 5-nit cap.
  148. - **CI/CD and autonomy tiers** — agent triage runs non-interactively in the pipeline; `org-loop.yml.example` dispatches one bounded turn and opens a PR without merging; dev is open, production needs a release manager, and rollback paths are rehearsed.
  149. - **Monitoring** — `bands.yaml` defines the control bands; 1σ logs, 2σ diagnoses, 3σ proposes a fix or runbook and writes the diagnosis back as a new intent.
  150. See `skills/ai-native-sdlc/references/adoption.md` for the staged rollout order.
  151. ## Layout
  152. ```text
  153. .
  154. ├── .codex-plugin/plugin.json # Codex plugin manifest (repo root is the plugin)
  155. ├── .github/workflows/self-check.yml # CI for this repo itself (validate + tests)
  156. ├── AGENTS.md # guidance for agents working in this repo
  157. ├── README.md
  158. ├── CHANGELOG.md
  159. ├── LICENSE
  160. ├── SECURITY.md
  161. ├── examples/
  162. │ ├── README.md
  163. │ └── expense-tracker/ # worked example + real static app (Vercel-ready)
  164. ├── tests/ # gate, scaffold, org, loop, band, eval tests
  165. └── skills/
  166. └── ai-native-sdlc/
  167. ├── SKILL.md # skill entrypoint (versioned; rule→enforcement matrix)
  168. ├── agents/openai.yaml # UI metadata
  169. ├── references/
  170. │ ├── playbook.md # phase-by-phase procedures
  171. │ ├── adoption.md # staged rollout + org customization
  172. │ ├── graph.md # the loop as a directed graph
  173. │ └── org.md # org roles, communication, memory, bounded loop
  174. ├── assets/ # templates copied into target projects
  175. │ ├── intent.md
  176. │ ├── spec.md
  177. │ ├── plan.md
  178. │ ├── CLAUDE.md
  179. │ ├── REVIEW.md
  180. │ ├── bands.yaml
  181. │ ├── production-gate.sh
  182. │ ├── pre-commit.example # secret-scan pre-commit hook
  183. │ ├── secrets-ignore.example
  184. │ ├── org/ # org chart, roles, messages, memory, loop
  185. │ ├── evals.example.md
  186. │ ├── evals.example.json
  187. │ ├── evals-README.md
  188. │ ├── workflow-graph.example.yaml
  189. │ ├── workflow-graph.yaml
  190. │ ├── incident.md
  191. │ ├── runbooks/ # rollback-deploy.md, README.md
  192. │ ├── PULL_REQUEST_TEMPLATE.md
  193. │ ├── gates-README.md
  194. │ ├── hook-settings.example.json
  195. │ ├── agent-evals.yml.example
  196. │ ├── org-loop.yml.example
  197. │ └── managed-settings.example.json
  198. └── scripts/
  199. ├── init_workflow.py # scaffolds the artifact skeleton
  200. ├── init_org.py # scaffolds the autonomous agent org
  201. ├── sync_issues.py # GitHub issue intake (pull/push)
  202. ├── quick_validate.py # skill/plugin self-check
  203. ├── run_evals.py # eval-suite runner (Phase 4)
  204. ├── detect_bands.py # control-band detection (Phase 6)
  205. ├── gate_ledger.py # hash-chained approval ledger (all gates)
  206. ├── workflow_state.py # graph state runtime (status/advance/check)
  207. ├── check_plan_sync.py # deterministic plan-sync enforcement
  208. ├── scan_secrets.py # deterministic secret scanner (build guardrail)
  209. ├── org_common.py # shared org helpers
  210. ├── org_message.py # agent-to-agent message bus
  211. ├── org_memory.py # context digest + event log
  212. ├── org_loop.py # bounded deterministic work loop
  213. ├── org_status.py # agent busy/idle + review queue
  214. └── intake.py # form/email demand intake
  215. ```
  216. ## Contributing
  217. Contributions are welcome — this repo practices what it ships. Open an issue
  218. first for larger ideas (new phases, changed artifacts, redesigns); for fixes
  219. and small improvements, fork, branch, and open a pull request.
  220. ### Getting started
  221. 1. Fork the repo and clone your fork.
  222. 2. Create a branch: `git checkout -b my-change`.
  223. 3. Make your change, then run the self-check suite from the repo root:
  224. ```bash
  225. python3 skills/ai-native-sdlc/scripts/quick_validate.py skills/ai-native-sdlc
  226. bash tests/test_gate.sh
  227. bash tests/test_init.sh
  228. python3 skills/ai-native-sdlc/scripts/scan_secrets.py --path skills
  229. python3 -m unittest discover -s tests -v
  230. ```
  231. All checks must pass before opening the PR — CI runs the same checks on
  232. every pull request (`.github/workflows/self-check.yml`).
  233. 4. Add a `CHANGELOG.md` entry under `[Unreleased]` for user-visible changes.
  234. 5. Commit with a clear message and open the pull request.
  235. ### Conventions
  236. - Templates in `skills/ai-native-sdlc/assets/` are copied into target
  237. projects — never edit them to fit one project; change
  238. `scripts/init_workflow.py` when the scaffold layout changes.
  239. - Keep `SKILL.md` short; put phase detail in `references/`.
  240. - Keep artifacts generic — organization specifics belong in the adopter's own
  241. skills and hooks, never in shared templates.
  242. - Keep `plugin.json` and the SKILL.md frontmatter `version` in sync (semver);
  243. `quick_validate.py` enforces this.
  244. - Follow the existing commit style: `feat:`, `fix:`, `docs:`, `chore:`, `test:`.
  245. ### Reporting vulnerabilities
  246. Security-sensitive bugs (release-gate bypasses, hook failures,
  247. managed-settings weaknesses) should not be filed as public issues. See
  248. `SECURITY.md` for how to report them privately.
  249. By contributing, you agree your contributions are licensed under the MIT
  250. license (see `LICENSE`).
  251. ## Attribution and license
  252. Based on [The AI-Native SDLC playbook](https://claude.com/blog/the-ai-native-sdlc-playbook) by Anthropic's Applied AI team (2026). MIT licensed — see `LICENSE`.

Ratings and comments

Sign in to rate this skill.

Sign in

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