Skip to content

Built-in templates

The New pipeline dialog (the + on a project in the sidebar, a project’s Pipelines tab, or ⌘K) offers four templates under Or start from a template. Choosing one creates a new, fully editable pipeline and opens it in the editor. Templates are starting points: nothing links the pipeline back to the template afterwards.

For pipelines outside software delivery (accounting, marketing, sales, executive reporting and support), see the template library on the website. Each one is a pipeline JSON you paste under Or import a pipeline JSON.

When created inside a project, the pipeline uses the project’s workspace, and template variables the project already provides (for example testCommand from a Test command) are dropped.

Template Steps Workspace Harnesses Human gate Max concurrent runs
Demo (Simulator) 8 Empty folder Simulator yes 0 (unlimited)
Feature: Plan → Build → Review → PR 7 Git worktree Claude Code, Codex yes 2
Bug fix (fast lane) 4 Git worktree Claude API, Claude Code no 3
Blank pipeline 1 Git worktree Claude Code no 0 (unlimited)

The Git worktree templates leave Local repository empty. Set it (or put the pipeline in a project with a workspace) before running; until then, runs can’t start.

Full Jimothy flow with simulated agents: triage, plan, build, test, review loop, approval, ship. No setup needed.

Created as Demo: Issue to PR (simulated), and seeded automatically on first launch. Workspace: Empty folder, base branch main, branch template jimothy/{{issue.key | slug}}-{{run.number}}.

triage ─► plan ─► implement ─┬─► tests ─┬─► review ─► approve ─► ship
└─► lint ─┘ │
▲ │ loop back (max 2)
└───────────┘
# Step (id) Type Harness · model Runs after Options
1 Triage (triage) Agent Simulator · fast —
2 Plan (plan) Agent Simulator · realistic triage Plan prompt
3 Implement (implement) Agent Simulator · realistic plan Implement prompt, retries 1
4 Unit tests (tests) Agent Simulator · fast implement
5 Lint & typecheck (lint) Shell — implement echo Linting {{run.branch}} && sleep 1 && echo "0 problems"
6 Code review (review) Agent Simulator · realistic tests, lint Review prompt, pass VERDICT:\s*APPROVE, loop back to implement, max 2
7 Human approval (approve) Approval — review “Review the changes for {{issue.key}} and approve to open the pull request.”
8 Open pull request (ship) Shell — approve echo Pushing {{run.branch}} && sleep 1 && echo https://github.com/acme/app/pull/$FACTORY_RUN_NUMBER

The Simulator’s realistic reviewer requests changes on the first pass and approves on the second, so every demo run shows one feedback loop. The final step prints a fake GitHub PR URL, which Jimothy detects and shows as a PR link on the run.

The Triage prompt is:

Classify and scope issue {{issue.key}}: {{issue.title}}
{{issue.description}}

The Unit tests prompt is Run the unit test suite and report results. Plan, Implement and Review use the shared prompts below.

Claude Code plans with Opus and builds with Sonnet, your tests run, Codex reviews (looping back on requested changes), you approve, a PR is opened.

Pipeline description: “Multi-harness feature pipeline with cross-model review and a human gate.” Workspace: Git worktree, base branch main, branch template jimothy/{{issue.key | slug}}. Variables: testCommand = npm test.

plan ─► branch ─► implement ─► test ─► review ─► approve ─► pr
▲ │ │
└─────────┴────────┘ loop back (max 2 each)
# Step (id) Type Harness · model Runs after Options
1 Plan (plan) Agent Claude Code · opus — Plan prompt, timeout 20 min
2 Create branch (branch) Shell — plan Branch command (below), timeout 5 min
3 Implement (implement) Agent Claude Code · sonnet branch Implement prompt, timeout 60 min, retries 1
4 Run tests (test) Shell — implement {{vars.testCommand | raw}}, timeout 20 min, loop back to implement, max 2
5 Cross-model review (review) Agent OpenAI Codex CLI · gpt-5-codex test Review prompt, pass VERDICT:\s*APPROVE, loop back to implement, max 2, timeout 20 min
6 Human approval (approve) Approval — review “Approve to push {{issue.key}}-{{issue.title | slug}} and open a pull request for {{issue.key}}.”
7 Open pull request (pr) Shell — approve PR command (below), timeout 5 min

The Create branch step runs after Plan and before Implement. It names a branch after the issue and checks it out from the latest base branch:

Terminal window
git fetch -q origin {{run.baseBranch}} &&
base={{issue.key}}-{{issue.title | slug}} && b="$base" && n=2 &&
# If the branch already exists locally or on origin, add -2, -3, ... to the name
while git show-ref --verify --quiet "refs/heads/$b" || git ls-remote --exit-code --heads origin "$b" >/dev/null 2>&1; do b="$base-$n"; n=$((n+1)); done &&
git checkout -q -b "$b" origin/{{run.baseBranch}} && git branch --show-current
  • It fetches the base branch and branches from origin/<base>, not from a local <base>. Checking out main fails inside a git worktree when the main checkout already has it, and origin/<base> is also the latest version.
  • If a branch with that name already exists locally or on origin, it adds -2, -3, and so on.
  • Its output is the branch name, e.g. ENG-12-add-dark-mode. Later steps work on that branch, and Open pull request pushes it.
  • In a multi-repository workspace, the step runs in every repository and each picks its own suffix, so the names can differ between repositories.

Pipelines you created from the Feature template before this step existed keep their old steps. Add a Create branch step yourself if you want it.

Requirements: Claude Code and Codex installed and signed in (or switch the review to another harness), your test command, and an authenticated gh CLI with push access for the last step.

Claude API triages the bug, Claude Code reproduces and fixes it with a regression test, tests run, PR opens automatically.

Pipeline description: “Reproduce, fix, test, ship. No human gate.” Workspace: Git worktree, base branch main, branch template fix/{{issue.key | slug}}. Variables: testCommand = npm test.

triage ─► fix ─► test ─► pr
▲ │
└──────┘ loop back (max 2)
# Step (id) Type Harness · model Runs after Options
1 Triage (triage) Agent Claude API · claude-opus-5 — Triage prompt (below)
2 Reproduce & fix (fix) Agent Claude Code · sonnet triage Fix prompt (below), timeout 45 min
3 Run tests (test) Shell — fix {{vars.testCommand | raw}}, loop back to fix, max 2
4 Open pull request (pr) Shell — test PR command (below)

Triage prompt (runs on the API harness, so it has no file access and works from the issue text alone):

Bug report {{issue.key}}: {{issue.title}}
{{issue.description}}
Summarize the likely root cause areas, a reproduction strategy, and the regression test that should be written. Be concise.

Fix prompt:

Fix bug {{issue.key}}: {{issue.title}}
{{issue.description}}
Triage notes:
{{steps.triage.output}}
{{#if steps.test.output}}
The previous fix failed the test suite:
{{steps.test.output | truncate:4000}}
{{/if}}
First write a failing regression test, then fix the bug, then commit referencing {{issue.key}}.

There’s no approval step: when tests pass, the branch is pushed and a PR opened automatically. Add an approval step before pr if you want a gate.

Start from scratch.

Created as New pipeline. Workspace: Git worktree, base branch main, branch template jimothy/{{issue.key | slug}}. One step:

# Step (id) Type Harness · model Prompt
1 Build (build) Agent Claude Code · sonnet Resolve {{issue.key}}: {{issue.title}} + blank line + {{issue.description}}
You are the planning agent on Jimothy, an automated software delivery crew.
Issue {{issue.key}}: {{issue.title}}
{{#if issue.url}}Link: {{issue.url}}{{/if}}
{{issue.description}}
Study the repository in the current working directory and write a concise, concrete implementation plan:
1. Files to change or create, and why.
2. Edge cases and risks.
3. How the change will be verified (tests to add or run).
Do NOT modify any files. Output only the plan in Markdown.
You are the implementation agent on Jimothy, an automated software delivery crew.
Work in the current directory, on the git branch already checked out there (in a folder of several repositories, each one's). Don't switch branches or create other clones or worktrees: the steps after you test and ship what's here.
Issue {{issue.key}}: {{issue.title}}
{{issue.description}}
Implementation plan from the planning agent:
{{steps.plan.output}}
{{#if steps.review.output}}
A reviewer requested changes on the previous attempt. Address every point:
{{steps.review.output}}
{{/if}}
Implement the change completely, add or update tests, and make sure the project builds and tests pass.
Commit your work with a descriptive message referencing {{issue.key}}.
Finish with a short summary of what you changed.
You are a strict senior code reviewer on Jimothy, an automated software delivery crew.
Review the changes on the current branch against {{run.baseBranch}} (use `git diff {{run.baseBranch}}...HEAD`)
for issue {{issue.key}}: {{issue.title}}
{{issue.description}}
Check correctness, tests, security and code quality. Do not modify files.
End your answer with exactly one line:
VERDICT: APPROVE
or
VERDICT: CHANGES_REQUESTED
followed by a numbered list of required changes if any.
Terminal window
git push -u origin HEAD && gh pr create --base {{run.baseBranch}} --title "$FACTORY_ISSUE_KEY: $FACTORY_ISSUE_TITLE" --body "Automated by Jimothy run #$FACTORY_RUN_NUMBER. $FACTORY_ISSUE_URL"

The Feature and Bug fix templates share it. It pushes and opens the pull request for whichever branch is checked out, so it follows the branch made by Create branch rather than the run’s own branch. {{run.baseBranch}} is shell-quoted automatically; the title and body use environment variables inside double quotes. gh pr create prints the PR URL, which becomes the run’s PR link.