Make Any Project AI-Native in One Command

Every team I talk to has the same quiet problem. They've adopted Claude Code, or Codex, or OpenCode. The demos are magic. But the first hour in a real repo is anything but — you're hand-writing a CLAUDE.md, copying a skills folder from the last project, half-remembering which MCP servers you had wired up, and wondering why the agent keeps rediscovering things it should already know.

The tools got good. The setup stayed manual. So we built something to fix it, and today I'm sharing it.

[create-ai-native-project](https://www.npmjs.com/package/create-ai-native-project) is an interactive CLI that makes a project AI-native from the first command. One line:

npm create ai-native-project

That's it. Answer a few questions and you walk away with an instructions file, reusable skills and agents, runnable stack boilerplate, a docker-compose, and CI — all wired to whichever agentic coding tool your team actually uses. (Prefer a different name? create-ai-native-starter is a published alias that runs the exact same wizard.)

What "AI-native" actually means

I don't mean "has an AI feature." I mean a repository your coding agent understands the moment it opens it. I have argued before that AI-native organizations will outperform AI-assisted ones — this tool is what that conviction looks like at the repository level. It comes down to a few things being present and correct from day one:

• An instructions file the agent reads first — CLAUDE.md for Claude Code, AGENTS.md for the others — describing the project, its conventions, and how to extend it.
• Skills and agents that encode your standards instead of living in someone's head — which matters more every year, because senior judgment is getting scarcer, not cheaper. Every project ships with a core set automatically: engineering-standards, knowledge-base, and using-create-ai-native-project skills, plus code-reviewer and security-reviewer agents — review being exactly the kind of judgment you can't delegate to the machine, so it deserves first-class tooling.
• MCP servers already configured — a curated developer set covering Chrome DevTools, Playwright, Context7, GitHub, Filesystem, Git, Fetch, Sequential Thinking, and Memory — written to each tool's own config (.mcp.json, opencode.json, .codex/config.toml) so the agent has real capabilities, not just good intentions.

When those are in place, the agent stops guessing and starts contributing. It is the same argument I made about why AI agents need a company, not just a prompt: structure beats cleverness.

What it asks you

The wizard walks through the decisions that matter and skips the ones that don't:

1. Which agentic tools — Claude Code, OpenAI Codex, OpenCode, and/or Cline. One source of truth gets retargeted to each tool's native format, so a mixed team isn't maintaining four copies of the same guidance.
2. Single project or monorepo — monorepos come as Turborepo + pnpm workspaces, apps grouped cleanly under apps/.
3. Your stack — React, Next.js, React Native, Flutter, NestJS, Laravel, Python FastAPI, or Streamlit. Each one ships runnable boilerplate, a Dockerfile, CI job fragments, and a specialist agent that knows that stack.
4. The plumbing — databases (Postgres, MySQL, MongoDB), storage (MinIO, AWS S3), auth (JWT, Clerk). Each choice contributes instruction sections and compose services.
5. The extras — a Docusaurus docs site, CI for GitHub Actions or GitLab, and a docker-compose composed from everything you picked.

Everything is assembled from a central template registry, cloned locally on first use — so the output isn't a frozen snapshot. It improves as the registry does, and a single update command refreshes it.

It respects the code you already have

The part I'm most proud of is what happens on an existing project. Run the bare command inside a repo and it detects that, then adds rather than overwrites. New selections are appended and merged into your CLAUDE.md, package.json, docker-compose.yml, and CI. MCP servers you already have configured are left alone.

Every scaffolded project also carries a small .ai-native-project.json recording its type, stacks, apps, and choices. Re-runs read it to skip what's installed and keep things consistent — and the coding agent reads it too, before it extends the project. Adding a new app to a monorepo six months from now is just running the CLI again; it slots in the new service, CI job, and instructions section without disturbing the rest.

Try it in thirty seconds

# interactive wizard, new or existing project
npm create ai-native-project

# create a folder and scaffold into it
npx create-ai-native-project --boot my-app

# refresh the local template registry
npx create-ai-native-project update

Requires Node 20.12 or newer. It's MIT-licensed and open source — the code is on GitHub, the full guides and demos live in the documentation, and I'd genuinely welcome issues, template contributions, and pull requests.

Why we built it

At GeekyAnts we start a lot of projects, across a lot of stacks, for a lot of clients. The pattern was impossible to ignore: the teams getting real leverage out of AI coding tools weren't the ones with the fanciest prompts — prompt craft helps, but it cannot compensate for a repository the agent can't read. The winners were the ones whose repositories were legible to an agent from line one. That setup work was real, repeatable, and exactly the kind of thing that should be a command, not a ritual.

So we turned our own house style into a tool and gave it away. If it saves you the first awkward hour on your next project, it did its job.

Give it a spin and tell me what breaks. I read every issue.

create-ai-native-project is built and maintained by GeekyAnts. If you're shipping an AI-native product and want a team that moves fast, let's talk — or reach out directly at pratik@geekyants.com.