nick-vels-skills

Autopilot is a development framework packaged as a skill. It takes your idea, asks questions exactly where the idea forks, and then does the rest on its own: writes the spec, thinks through what you didn't, splits the work into tasks and builds the whole project. You don't have to read the spec, size the tasks or understand the code.

It works on its own: nothing else to install.

And you can always see what's going on. At the start of a build the agent opens the dashboard itself — a single HTML file you never have to find or launch. The header colour tells you the state at a glance: blue — the build is running, orange — it's waiting for your answer, green — done. Below: what is happening right now, how much is left, every task as a coloured bar and every one of your requirements in your own words. Timers tick live, the page refreshes itself, no internet needed.

---

Installation

If you'd rather not open a terminal

Open your AI agent — Claude Code, Cursor, Codex — and paste this:

Install the Autopilot skill for me. Run in the terminal:

npx skills add nick-vels/skills --skill autopilot -g -y -a <put yourself here: claude-code, cursor, codex>

If npx is not found, give me a link to download Node.js and wait.
Don't install anything else.
When you're done, tell me in one line that it's ready and that the session needs a restart.

The agent does the rest. Then restart it — skills are loaded at startup.

This command is for the first install. Updating later is a different command.

From the terminal

Copy this line:

npx skills add nick-vels/skills

The installer asks which skills to install and for which agents — just confirm.

npx skills add nick-vels/skills --skill autopilot -a claude-code -g -y

Flag	What it does
--skill autopilot	Installs only Autopilot
-a claude-code	Installs for Claude Code
-g	Globally — the skill is available in every project
-y	Don't ask questions

Without -g the skill is installed into the current project folder only.

Requires: Node.js (for npx) and any supported AI agent — Claude Code, Cursor, Codex and 70+ others. Nothing else.

---

How to use it

Open your agent in the folder of the future project and type:

/autopilot I want a Telegram bot that takes repair requests for appliances
and puts them into a Google Sheet

Autopilot starts only on this command. It never starts by itself, even if you write "just build it": it creates a repository, writes code and commits, and that should only begin when you say so.

If the task is big, put it in a file. A detailed description doesn't fit in one chat line, and you shouldn't cut it short: the more you tell, the less has to be guessed for you. Create a file next to the project — any name, brief.md, idea.txt, task.md — and describe everything in free form: what the project is, who it's for, what it must do, what you dislike about competitors, any budget and deadline constraints. Then just point to it:

/autopilot brief.md

/autopilot deep docs/idea.md but no card payments

The agent reads the file and takes its contents as the task; your file stays untouched, and a copy goes into .autopilot/ — that copy is what the result is checked against at the end. Words written after the path are added to the same task.

After that, all you do is answer a few questions at the very beginning.

The agent's first reply tells you which mode it's in and what other modes there are, and it opens the dashboard itself — no commands to remember, no files to look for:

Mode: semi-auto · depth: normal — I'll only ask what the task leaves undecided, then build the rest myself.
Dashboard is open and refreshes itself: http://localhost:52814/dashboard.html
Project memory — AGENTS.md (+ CLAUDE.md pointing to it).

You can switch at any time, just say:
• "fully automatic" — I ask nothing at all
• "interview me" — I go through the task with questions to the end, then build it myself
• "approve every step" — the same, plus you approve the spec and the task list
• "strictly as written" / "go deep" — less or more elaboration beyond what you said

Questions come in rounds: several at once, numbered, each with the answer the agent would pick itself. Agree with all — reply "ok"; disagree with one — "2 — a spreadsheet, the rest ok".

---

Four modes

After /autopilot you can add how closely you want to be involved. Add nothing — you get semi-auto.

Mode	How to turn it on	What you're asked
Fully automatic	/autopilot full ... or "fully automatic"	Nothing. At the end — a list of decisions made for you
Semi-auto (default)	nothing to add	Only what the task leaves undecided: usually one or two rounds of questions. If everything is clear — none
Interview	/autopilot interview ..., "interview me", "ask me everything"	Every fork, plus where the idea might not work. Then it builds on its own
Manual	/autopilot manual ... or "approve every step"	Same as interview, then your "ok" on the spec and on the task list

/autopilot full a landing page for pizza delivery

/autopilot A Telegram bot for booking manicure appointments

/autopilot manual CRM for a car repair shop, I want to approve the spec myself

The words full, semi, interview, manual are written without dashes. You can change the mode along the way — "switch to manual" — it applies from the next stage.

What no mode changes: the agent asks before anything irreversible — publishing, payments, messaging people, deleting data. And no mode turns off the check against your original task.

---

Depth

A separate dial, independent of the mode. The mode decides how much you're asked; depth decides how much is thought through for you.

Depth	How to turn it on	What the agent does
Strict	/autopilot strict ... or "strictly as written"	Only what you wrote. No features of its own — not even good ones. Errors and empty states are still handled: without them a requirement simply doesn't work
Normal (default)	nothing to add	Works through the gaps that would clearly spoil the result. It may add things of its own, but each tied to one of your requirements
Maximum	/autopilot deep ... or "go deep", "think it through"	Every requirement goes through the full checklist: first run, empty screen, bad input, failure, dropped connection, growth, permissions, consequences

/autopilot strict a feedback form, exactly as I described

/autopilot deep an online ceramics store

/autopilot full deep a marketplace for craftspeople

Word order doesn't matter, both settings are optional. Like the mode, depth can be changed along the way: "less improvising" or "think it through more".

One rule holds at every depth: anything the agent adds on its own is tied to one of your requirements and listed separately in the final report. A feature not tied to anything gets cut.

---

Reference — what it should look like

If there are sites, apps or texts the result should resemble, say so when the agent asks during the briefing. They go into reference.md and are handed to the agents that build what you will see: the interface is made "like that one" from the start, not adjusted afterwards. The agent never passes off its own taste as yours — a reference only ever comes from you.

---

Two things Autopilot does differently

Your task doesn't get lost along the way

The usual problem with building "from a description": you dictate a big brief, then come questions, a spec, tasks, code — and at the end half of what you asked for just isn't there. Not because anyone refused, but because at some step it stopped being mentioned.

Autopilot's first move is to split your text into numbered requirements and write them down word for word. From then on each requirement has a status, and every stage has a check:

• after the spec — no requirement is left without a section;
• after the split — every requirement has a task, and every task has a requirement (this catches work nobody ordered);
• at the end — blind acceptance: a separate agent gets only your original text and the finished project, not the spec. It checks the result against your words, not against a retelling. If it and the tracker disagree, you'll see that in the report.

Only you can drop a requirement. The agent may suggest deferring one — it may not strike it out. Silence doesn't count as cancelling.

What you didn't think of is thought through for you

In a brief you describe how things work when everything goes well. You don't describe what to show on an empty screen, what happens when the connection drops, what happens if someone presses "send" twice, or what a person sees on the very first run. That's not an oversight — it's just not the level at which people describe a task.

Thinking this through is a large part of Autopilot's value, and you set how much of it happens with depth. At normal depth the agent closes the gaps that would clearly spoil the result; at maximum depth it runs every requirement through the full checklist. Some things it decides itself (an error message, sensible limits); where the decision really is yours, it turns it into a question.

At maximum depth one requirement from the brief unfolds into several worked-out scenarios — as many as it really has sides. That's the difference between "works in the demo" and "works".

---

Progress is always visible

.autopilot/dashboard.html opens by itself at the very start of the build — nothing to find or launch. If the agent can show a page inside its own window (for example, the side pane in the Claude app), the dashboard opens there and everything stays in one window; otherwise in your browser. In a narrow pane next to the chat it gets denser: the same blocks, without the giant numbers. Works offline. While the build runs, the page pulls fresh numbers every ten seconds — without reloading, so your scroll position and selected text stay put; the ⟳ arrow at the top refreshes at once. Next to it are the theme (light / dark) and language (RU / EN) switches; until you touch the theme, the dashboard follows your system.