Skip to content
iamalissonPublic

Repository files navigation

landspec

Spec Kit, with the boring parts done.
Every task gets an issue, a branch and a pull request. Every commit gets checked. Every project starts with the right defaults.

Formerly jit-speckit. Upgrading from it: docs/releases/2.0.0.md.

Tests Claude Code plugin spec-kit v1.2.5 Linux and macOS

spec and tasks once per feature; then, for every task, in parallel and automatically: issue, branch, pull request, merged and issue closed


GitHub Spec Kit turns a feature idea into a spec, a plan and a task list, and Claude writes the code. landspec plugs into it and handles everything around that code:

  • every task gets a GitHub issue, its own branch and its own pull request;
  • secrets are refused at commit and push, and every pull request passes a security gate;
  • the project's constitution starts with security, testing and simplicity defaults, sized to how serious the project is.

You plan the feature and review the work. Claude writes the code, and landspec does the rest the same way every time.

Install

In Claude Code:

/plugin install landspec --marketplace iamalisson/landspec

Needs Claude Code 2.1.295 or newer: from that version the command guard blocks a command when it times out or crashes.

That one command is the whole install. Don't run specify init yourself: /landspec:init sets up spec-kit in your project, for Claude, at the version landspec is tested with.

What your machine needs first:

Tool Why Check
Claude Code 2.1.295+ runs landspec claude --version
git branches and commits git --version
GitHub CLI, logged in issues and pull requests gh auth status
uv installs spec-kit's specify CLI uv --version

If specify is missing, /landspec:init offers to install it with uv. A project already set up with specify init for another agent (such as --integration copilot) needs Claude added first: specify integration add claude.

Update

claude plugin marketplace update landspec && claude plugin update landspec@landspec

Then /reload-plugins, and /landspec:init once in every project that already uses it: each project keeps its own copy of the extension under .specify/, and only init refreshes it (it keeps the level). Details: docs/reference.md.

Start

Your project Run Then
New (empty folder) /landspec:new the foundation spec it suggests: you pick the stack together with Claude, and it sets up the project (tooling, CI, containers) and landspec. To set up only landspec and describe the project yourself, run /landspec:init, then /speckit-constitution
Existing (has code, no spec-kit yet) /landspec:init nothing: it reads your code and fills the constitution for you

init asks one question: how serious the project is (lite, standard or full, see Levels). It changes nothing in your code and commits nothing; you review the setup and commit it to the base branch (develop on standard and full; init offers that PR), because task branches start there. What new asks and sets up: docs/reference.md.

The loop

How often Run What you get
Once per feature /speckit-specify "what and why" the spec
(optional) /speckit-clarify fewer open questions, before planning
/speckit-plan the technical plan
/speckit-tasks the task list, grounded in the real code, one issue per task, and a spec PR
(optional) /speckit-analyze a consistency check (required on full)
merge the spec PR
Then, once per feature /landspec:implement every startable task at once, each in its own copy: its branch → code → checks (tests, mutants) → review → PR; a task that depends on another is stacked on its PR. Then all of them checked together against the suite and the spec, and any gap filed as a new task
merge the PRs, in the order it prints the issues close; run it again for what is left
(or, once per task) /landspec:next progress, then the next open task, the same way, one at a time; it offers /landspec:implement when two or more can start. Several features? next 002
(optional, once per project) /landspec:aws the AWS access layer on: .mcp.json, the "Cloud access" rules, and the deploy command for the read-only or build agent role, for you to run; landspec itself makes no AWS call
When every task is merged /landspec:implement the full security audit, unattended, then the release PR, the tag and the release, one step per run; a confirmed critical or high holds the release

Small fixes don't need the feature loop. A typo, a one-line bug fix or a dependency bump goes on a normal branch with a normal PR, through pr.sh fix. The independent review, the hooks and the CI gate still apply: no PR opens without a review, at any level. The spec, issue and per-task flow are for features.

The spec PR and the task PRs are separate on purpose: task branches start from the base branch and need tasks.md there, and each task PR stays small and closes one issue. See examples/ for one feature walked through from spec to merged PRs, with the real issue and PR bodies.

When every task is merged, run /landspec:implement again, however the tasks were done: it checks the whole feature on the base against the spec (once per commit; gaps become new tasks), audits the base (/landspec:security full, unattended, once per commit) and makes the release. A confirmed critical or high finding holds it, with nothing filed or posted, and the run ends with run /landspec:security <report>, which tracks and fixes it without disclosing it.

/landspec:next picks the next task for you. /speckit-implement T007 does the same for a specific task. Either way, exactly one task per run.

Why one task = one issue = one branch = one PR, with the evidence: docs/design.md.

Security, built in

When Check
every commit refuses .env, keys and credential files, and tokens or passwords in the code. Under a second.
every command Claude runs blocks --no-verify, git add -A, commits on base branches and pushes to them, and gh pr create outside pr.sh (a promotion between long-lived branches aside)
every push re-checks every outgoing commit, including ones made with --no-verify
before each PR (one per task, /landspec:implement too) an independent review by a fresh agent (landspec:reviewer, on Sonnet unless review_model: says opus or fable), in its own copy of the reviewed commit, that reads the diff and the code around it in one fast pass (following personal data and secrets into the helpers that log them), like Copilot code review, with no subscription needed, scanners on the changed files (the PR is refused until they ran on its exact diff), /security-review
every PR, and weekly CI gate (standard and full): Gitleaks, OSV-Scanner and zizmor (Semgrep with the OWASP rules on full, from its image pinned by digest, its rules fetched from the Semgrep registry at run time; trivy on Dockerfiles and Terraform when the project has them), all pinned and checksum-verified
before a release /landspec:security, the full audit, run unattended by /landspec:implement before the bump; a confirmed critical or high holds the release

Why each layer exists, and what it can't do: docs/security.md.

Levels

Pick one at init, and change it any time with /landspec:level. Going down never deletes files.

lite standard (default) full
For prototypes, solo work products, small teams production, money, personal data
Branches feat/* → main feat/* → develop → main feat/* → develop → staging → main
Constitution defaults KISS, secrets, tests for logic, task = issue = PR + security baseline, stack idioms, dependency policy, integration tests + threat model per feature, data integrity, observability, releases
Added to the repo git hooks, PR template, .claude/settings.json without AI attribution (only when the project has none yet) + CI for your stack, security CI, Dependabot + Semgrep in CI, CODEOWNERS, SECURITY.md, release workflow
Before each PR asks first, then the independent review, recorded and required the independent review, recorded and required the same, and evidence is required
/speckit-analyze optional optional required before any task: its report is recorded, and a changed tasks.md needs a new one

Your stack is detected and shapes the CI and the constitution; your files are never overwritten. Details, the configuration keys and what runs automatically: docs/reference.md.

Help

/landspec:help shows every command, level and setting. Ask it anything: /landspec:help why is the spec a separate PR?

landspec got something wrong, or could do better? /landspec:report drafts an issue for this repository from what just happened (versions, the message, where in landspec it comes from, nothing private from your project), checks for duplicates, and files it once you say yes.

Uninstall

/landspec:remove takes landspec out of one project (--with-speckit also removes spec-kit's files, your constitution included); /plugin uninstall landspec removes the plugin from Claude Code. What remove deletes and keeps: docs/reference.md.

More

Releases

Packages

Contributors

Languages