Your AI software team that ships while you sleep
A Claude Code plugin that turns one terminal into a full delivery team — product manager, architect, tech lead, engineers, and QA. It reads a Jira ticket and ships the spec, plan, code, and review.
Terminal preview: /auto PROJ-142 runs the full delivery pipeline — reads the ticket, drafts the spec and plan, implements across specialized agents, passes the QA gate, and opens a reviewed pull request.
You don't lose time writing code. You lose it around the code.
The AI already writes the code. What still eats the sprint is the connective tissue: turning a vague ticket into a real spec, a spec into a plan, keeping the plan honest while you implement, then reviewing the result without rubber-stamping your own work.
Coding assistants handle the middle 20%. The other 80% — the process — stays manual, or gets skipped on vibes and shipped unreviewed.
Vague ticket, no spec
"Add auth" becomes whatever you remember at 4pm.
No enforced lifecycle
Runbooks exist. Nobody follows them without enforcement.
Self-review is a rubber stamp
Reviewing your own AI output isn't review.
One command runs the whole lifecycle
Point it at a ticket. It triages the work, then runs each stage in order and closes the loop back to your tracker — spec before plan, plan before code, review before merge, tests as the gate.
/auto triages by size. Stories at or under the lightweight threshold (default ≤3 points) skip the spec and plan and go straight to implementation.
Drive a stage yourself. Every stage has its own verb: /spec /plan /impl /review.
Review by day. Ship by night.
"Ships while you sleep" is a workflow, not a slogan. The split is simple: your day is for decisions, the night is for execution.
You refine
Every story gets pre-refined with clear acceptance criteria, and the complicated ones get a full spec. You read the refined stories and specs, decide what's ready, and approve them. You make the calls. You don't write the implementation.
The plugin implements
/auto picks up the tickets and specs you already approved, triages each one, and routes it to the right approach — following the practices your domain agents enforce for that repo (from its project-context.md). Nothing runs on work you haven't signed off.
You review
You wake up to PRs ready for review. Each one addresses acceptance criteria you already agreed to, or a spec you already approved. You're reading a result you set up, not a surprise.
You kept every decision. The plugin did the execution. Prefer to drive a stage yourself? Each one has a verb: /refine-issue /spec /impl /review.
A team, not a megaprompt
"Do everything" agents hallucinate across roles and leave no trail. nightshift splits the work across 11 agents, each with a tight charter, its own prompt and tools, and a clean handoff to the next. Narrow charters mean fewer hallucinations and an auditable artifact at every stage.
⊘ marks a hard gate — each phase ends there and control returns to you. Every ✶ is an agent with a tight charter. Hover any row to read its charter, contract, and source.
whimzyLive/nightshift-ai ↗⊘ every phase ends at a hard gate — control returns to you before the next one runs · hover a row for its charter
Why builders choose it
The lifecycle is the product
Spec → plan → implement → review, enforced by the commands and the handoff protocol. Tests are the merge gate. Review is done by a different agent than the one who wrote the code.
Generic agents, per-repo config
No hardcoding. Every project fact lives in one project-context.md. The same plugin runs a Node monorepo, a Python service, or a mobile app.
Issue-tracker native
It reads the ticket, derives the branch, plan, and PR, and comments the result back to Jira and GitHub.
Free, open, yours to fork
Built on open Claude Code primitives, MIT-licensed. Fork it, extend it, swap a role. No lock-in, no paid tier gate.
You decide how it gets built
Most AI dev tools abstract the process away until you can't see what you're getting — you only find out once the output lands, then negotiate your way back to what you meant. nightshift runs the opposite way: it keeps the software development lifecycle in front of you, with a hard gate at every phase that returns control before the next step runs.
Questions builders ask first
No. It's a process engine. The wedge is the SDLC, not the code. Assistants do the middle 20%; nightshift runs the other 80% — spec, plan, review, and the handoffs between them.
/auto triages by size. Stories at or under the lightweight threshold (default ≤3 points) skip the spec and plan and go straight to implementation.
The agents are fully generic. Every project-specific fact lives in one project-context.md file. The same plugin runs across a Node monorepo, a Python service, or a mobile app — you configure it once per repo.
Review is done by a different agent than the author, tests are the merge gate, and every stage leaves an artifact you can read — PRD, spec, plan, review. Nothing merges on vibes.
Nothing. It's free and MIT-licensed. Adoption is the only metric we track.
Put a ticket in tonight. Read a reviewed PR in the morning.
Install takes about a minute. Point it at a ticket and watch the spec, plan, code, and review land — with the paper trail linked back where your team already works.