Skip to content
Skills Library
Management & product · Planning

project

/project

Write a project file for a piece of work into .caddis/projects/active/ as project-<name>.md, without implementing it. Use when the user asks to create a project, write a plan or plan out a feature, including from an intent file or a ticket key. Triages small low-risk work to /caddis:task instead.

Repository
Caddis ↗
Licence
MIT
Last repository change
11.11.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
1
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 11.11.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

Write a project file for a piece of work into .caddis/projects/active/ as project-<name>.md, without implementing it. Use when the user asks to create a project, write a plan or plan out a feature, including from an intent file or a ticket key. Triages small low-risk work to /caddis:task instead.

Original author description

Write a project file for a piece of work into .caddis/projects/active/ as project-<name>.md, without implementing it. Use when the user asks to create a project, write a plan or plan out a feature, including from an intent file or a ticket key. Triages small low-risk work to /caddis:task instead.

How it works

  1. 0. Triage first
  2. 1. Gather
  3. 2. Write
  4. 3. Check
  5. Rules
Original SKILL.md headings · 141 lines, 1,003 words
SKILL.md preview
---
name: project
description: Write a project file for a piece of work into .caddis/projects/active/ as project-<name>.md, without implementing it. Use when the user asks to create a project, write a plan or plan out a feature, including from an intent file or a ticket key. Triages small low-risk work to /caddis:task instead.
---

Write a project file for the work described in my message. Do not implement it.

**Team rules.** If `.caddis/extend/project.md` exists, read it before anything else and
follow it. It adds to or overrides this skill, but it never removes a hard stop, weakens a
gate, silences a check or skips the gate-verifier.

## 0. Triage first

Read `.caddis/caddis.md`. If the work meets every condition for a task (see the
`task` skill: small, one layer, nothing on the Risk list, no Invariant touched, no
experiment needed), say so in one line and follow the `task` skill instead. If unsure,
it is a project.

## 1. Gather

- **The intent.** If my message names an intent file or a ticket key, read it (a ticket
  with the tracker tool in caddis.md's Product section). It is the brief: the project delivers
  its Outcome and Done when, and stays inside Out of scope. Link it; don't copy it. If the
  work changes what users see and caddis.md lists Product owners but there is no intent,
  say so in one line and carry on.
- Read `.caddis/caddis.md` and `.caddis/map/STRUCTURE.md`. If the map is missing or
  `python3 .caddis/bin/map.py status` says it is stale for the areas involved,
  refresh it first with the `map` skill.
- Read the docs listed under Docs in `caddis.md`, and at least one existing project in
  `.caddis/projects/active/` or `.caddis/projects/completed/` to match tone and shape.
- Read the code the project will touch. Use `python3 .caddis/bin/map.py uses <file>` to find
  what depends on it. Name nothing the code has not confirmed.
- If a Reference repo already solved this, read how.

## 2. Write

File: `.caddis/projects/active/project-<kebab-name>.md`. Concrete and technical, not
corporate. Short: about 60 lines for one phase, and each phase of a longer project fits on one
screen. **Leave out any section with nothing to say.** No "None" or "Skipped" lines; a
missing section means none. Goal, Summary, Context, Changes and Verification are always
there.

If the project changes a decision recorded in the Architecture doc or `caddis.md`, say so
plainly and argue for it. Never diverge quietly.

### Template

```markdown
# <Title>

**Status:** Pending
**Type:** Project | Master plan
**Phases:** <n>
**Depends on:** <project files, or None>
**Intent:** <intent file name or ticket key, or None>

## Goal
One sentence: what this achieves and why it matters to the user.

## Summary
For the product owner and anyone non-technical. Plain-language bullets: what changes for
users and why. Then:
**Done when:** the intent's checks, in its words (or your own, in product terms).
**Questions for product:** only scope or behaviour questions, each with a suggested answer.

## Context
What exists now, what is missing or broken. File paths and line numbers.

## Risk
Low / Medium / High and why, using caddis.md's Risk list. Mitigation: phasing, reduced
scope, flag, rollback. The metric or test that would catch a regression.

## Experiment
Only when caddis.md has Experiments set and this changes behaviour: variants (the approach,
real alternatives, current behaviour as baseline), how each runs (the real code path, the
benchmark command, nothing mocked), the Metrics that matter, the Threshold to adopt, and a results table
filled in before implementation starts.

## Key Reference Files
Files to read but not edit: the Architecture doc section, reference repo files.

## Changes
Every file that changes and how: functions, types, constants, new and deleted files. A
table if long. Name what is **reused**. Before proposing a new module, say what was
searched and why nothing existing fits.

## Invariants
Which numbered Invariants this touches and how each holds.

## Storage & State
Migrations, new files, settings keys, upgrade path for existing data.

## Phases
For large, risky or multi-layer work. Each phase: what it delivers and a gate a machine can
check (a test, a measurement, a file that exists). Each phase ends in its own commit. Lint,
typecheck and tests green are implied for every gate.

### Phase 1 - <name>
...

## Tests
New and changed logic to test, highest value first, per caddis.md's Tests priorities.

## Verification
Numbered end-to-end steps. Name the automated checks.

## Open Questions
Technical questions, each with a recommended default. /caddis:review asks the owner once;
the build never stops to ask.
```

The Summary follows the Writing rules in caddis.md's Product section. It is the only part
a product owner needs to read, and the part they sign off.

If caddis.md's Plans section lists Required sections, write those in their stated format at
the end. They replace `## Summary` unless Keep Summary is yes or
Product is on (caddis.md's Product owners line names someone). Follow its Other rules. A project with nothing for those readers gets the
Silent marker instead, if one is defined.

### Charts and flows

Optional; prose and tables are always fine. Each is YAML in a fenced block. Use Mermaid for
any other diagram.
- ` ```chart `: `title`, `better` (`lower` or `higher`), `rows` of `[label, number]` with an
  optional third item `winner` or `rejected`; optional `threshold` and `note`. For
  Experiment results.
- ` ```flow `: `title`, `steps` (name: detail, in order), optional `branch` list of
  `{from, if, to, tone}` where `from` and `to` name steps and `tone` is `good`, `bad` or
  `neutral`. For a lifecycle or state change the project introduces.

## 3. Check

Re-read the project against the code and the intent: every file named exists or is created by
the project, every Done when check is covered by Verification, nothing outside Out of scope is
built, every risk and side effect is covered, nothing is assumed. Fix it, then confirm the
filename and scope in two lines.

## Rules

- Master plans (`Type: Master plan`) list phases that each become their own project later.
- The project lands as its own `docs:` commit via the `commit` skill, unless `.caddis/` is
  gitignored (then there is nothing to commit).
- Phase headings must be `### Phase N - <name>` so progress tools can read them.
- An intent file that this project delivers gets `**Status:** Planned (project-<name>)`.

Versions

RepositoryScoreLicence
This page · adivmaimon/Caddis100MIT
LandonSchropp/agent-toolkit100MIT
stefanocaronia/claude-project100MIT
erayozenn/BigHead-2ndBrain100MIT
samchon/typia100MIT
systemfsoftware/systemfsoftware100Apache-2.0
systemfsoftware/systemfsoftware100Apache-2.0
kriegcloud/beep-beginners100Apache-2.0
cwinvestments/memstack100MIT

Database snapshot: 13.11.2026 · package version 0a63f26d1bbd (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100task
    Handle a small, low-risk change end to end - write a short task file in .caddis/projects/active/, make the change, verify, move it to completed and commit. Use when the user asks to create a task, make a quick fix or a small change. Escalates to /caddis:project if the work turns…
  • 100project-bootstrap
    Initialize a new project context before any task exists: project folder, charter file, references skeleton, and active/ and archive/ folders for tasks. Use when starting a brand-new project, product, initiative, or client engagement with no project folder yet, or when…
  • 100project-overview
    Use when the user asks about a specific project or all projects — e.g. 'show me project X', 'project overview', 'what projects do I have', 'project summary
  • 100setup
    Interview the user one question at a time and write the project's rules file, goals file, handoff file and release checklist. Use when starting a new app, adopting The Last Mile in an existing project, or when the user asks to set up or redo their project rules.
  • 81task_create
    Create exactly one new task file for one upcoming work item. Use when the user asks to make, add, file, write, or capture a single task or todo. Use task for listing, querying, updating, archiving, linting, or multi task backlog work.
  • 90planning
    Breaks a feature into ordered, verifiable tasks in a plan file and assigns a model per task. Use when the user asks for a plan, a task breakdown, or which model fits a plan task, or a change spans several files. Not for small edits or reviews.

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.