This project demonstrates a greenfield AI-assisted development workflow using spec-kit with a custom preset to build a Spring Boot 4 MVC application from scratch. Using the Pirate Speak preset, every specification, plan, task list, and implementation report was generated in full pirate vernacular — proving that presets can reshape the entire spec-kit experience without changing any tooling. The steps below document exactly what was done — you can follow the same process to build your own projects with your own presets.
Note on presets: A spec-kit preset is a package of custom templates, agent commands, and configuration that transforms how every agent behaves. The Pirate Speak preset replaces all default templates with pirate-themed equivalents — specs become "Voyage Manifests," plans become "Battle Plans," and tasks become "Crew Assignments." Presets are installed with a single command and apply automatically to all subsequent agent invocations.
- uv — Python package manager used to install spec-kit
- VS Code with the GitHub Copilot extension
- JDK 25 — required to build and run the generated application
- Maven 3.9+ — build tool
uv tool install specify-cli --from git+https://github.com/github/spec-kit.gitmkdir spec-kit-pirate-demo && cd spec-kit-pirate-demo
git init
specify init . --ai copilotThis scaffolded the spec-kit structure and installed the Copilot custom agents.
specify preset add --dev ../spec-kit-presets/pirateThis installed the preset from a local directory. The preset provides pirate-themed templates for every artifact type — specs, plans, tasks, checklists, and constitutions. Once installed, all agents automatically use the preset's templates instead of the defaults.
Tip: Presets can also be installed from Git repositories:
specify preset add https://github.com/user/preset-repo.git
code .All spec-kit agents are available in the Copilot Chat Agent mode. Open Copilot Chat, click the Agent dropdown (top-left of the chat input), and select the agent you want to invoke.
With the Pirate Speak preset installed, the agents available are:
| Agent | Purpose |
|---|---|
speckit.constitution |
Draft the Pirate Code (project constitution) |
speckit.specify |
Create a Voyage Manifest (feature spec) |
speckit.clarify |
Interrogate the manifest with clarifyin' questions |
speckit.plan |
Chart the Battle Plan (technical design) |
speckit.analyze |
Inspect the fleet fer consistency |
speckit.tasks |
Assign the Crew (dependency-ordered task list) |
speckit.checklist |
Generate a Ship's Inspection (quality checklist) |
speckit.implement |
Begin the Plunderin' (execute tasks) |
speckit.taskstoissues |
File crew assignments as GitHub Issues |
The speckit.constitution agent was invoked with:
Write a constitution for quick Spring Boot prototyping
This created .specify/memory/constitution.md — "The Pirate Code o' Quick Spring Boot Prototypin'" — establishing six articles: Speed Above All Else, Lean Cargo, Prove It Works, Expose the Plunder, Keep the Decks Clean, and Quick Deployment. All subsequent agents respected these principles automatically.
The speckit.specify agent was invoked with:
Create a minimal Spring Boot MVC application
This generated a Voyage Manifest with three Crew Tales (user stories), each independently testable: a Thymeleaf welcome page (P1), an Actuator health check (P2), and a JSON greeting API (P3).
The speckit.plan agent was invoked with:
Create a plan for the spec. I am building with Java 25 and Spring Boot 4
The agent researched Spring Boot 4's release notes and migration guide, discovered that spring-boot-starter-web is deprecated in favor of spring-boot-starter-webmvc, that @AutoConfigureMockMvc moved to a new package, and that Jackson 3 is the default JSON library. All findings were captured in a research document and the Battle Plan was updated accordingly.
The speckit.tasks agent was invoked with:
Break the plan into tasks
This produced 21 dependency-ordered Crew Assignments across 6 phases, with parallel execution opportunities identified and each crew tale independently implementable after the foundational phase.
The speckit.implement agent was invoked with:
Start the implementation in phases
The agent executed all 21 tasks sequentially across the 6 phases, creating the full Spring Boot 4 application with passing tests.
A greenfield Spring Boot 4 MVC application — specified, planned, and implemented entirely through structured agent workflows powered by the Pirate Speak preset. Every artifact generated during the process reflects the preset's personality:
| Default Artifact | With Pirate Preset |
|---|---|
| Feature Specification | Voyage Manifest |
| Implementation Plan | Battle Plan |
| Task List | Crew Assignments |
| User Stories | Crew Tales |
| Tests | Sea Trials |
| Constitution | The Pirate Code |
The preset required zero changes to spec-kit's tooling — it controlled the experience through two mechanisms:
- Custom templates — the preset overrides the default artifact templates (spec, plan, tasks, checklist, constitution) with pirate-themed structure — section headings like "Crew Tales" instead of "User Stories," "Battle Plan" instead of "Implementation Plan"
- Custom commands — the preset's command files instruct each agent to write and respond in pirate speak, which serves a dual purpose: the agent fills the pirate-themed templates with pirate speak content (not just pirate headings with plain English beneath them), and it responds conversationally in pirate speak too (status updates, progress reports, checkpoint messages)
Both live inside the preset package — templates in templates/ and commands in commands/. The same workflow that produced pirate-themed artifacts and dialogue here would produce formal enterprise documentation with a different preset, or concise startup-style specs with another.
This walkthrough demonstrates that spec-kit presets can reshape every layer of the AI-assisted development experience — not just cosmetically, but structurally. The same agents that produce formal enterprise specifications in one project produced pirate-themed Voyage Manifests, Battle Plans, and Crew Assignments in this one, without a single change to spec-kit itself.
The pirate theme is deliberately absurd, but the mechanism behind it is not. A preset that replaces "User Stories" with "Crew Tales" and instructs the agent to write in pirate speak is architecturally identical to one that enforces a company's internal documentation standard, applies regulatory compliance language, or outputs artifacts in a specific human language. The templates control the structure of what gets written; the commands control the voice and tone of how it gets written. Together they define the full personality of the workflow.
What makes this interesting is the degree of control a preset author has without touching any code. The Pirate Speak preset is a directory containing Markdown files — templates and commands — nothing more. It was installed with a single CLI command and immediately applied to every agent invocation that followed. Removing it would revert every agent back to its default behavior. This makes presets a low-risk, high-leverage way to standardize how teams use spec-kit across projects.
For teams considering building their own presets: start by copying the default templates, then modify the structure and terminology to match your organization's conventions. Add command overrides to shape the agent's tone, level of detail, or domain-specific vocabulary. The result is a portable, versionable package that ensures every project in your organization produces consistent artifacts — whether those artifacts sound like a corporate standards body, a startup pitch deck, or a pirate ship.