# Agentic coding starter kit — rules, skills, knowledge, plans

Companion artifact to curriculum module 06 (AI builds the feature) at
https://lyceumagents.com/curriculum/ai-builds-the-feature/

Four templates, extracted from the working system that built the
curriculum itself (the lyceumagents repo). Adapt the words; keep the
economy: rules pay rent every session, skills load on demand, knowledge
docs persist the architecture, plans gate one feature and retire.

Works with any agentic coding tool that reads repo-level instructions —
Claude Code (CLAUDE.md + .claude/skills/), Google Antigravity (rules +
workflows), and the AGENTS.md-convention family. The mechanism is shared:
files of instructions, advertised by name and description, matched to
the task at hand.

---

## 1. The rules file (CLAUDE.md / AGENTS.md) — always loaded, so short

```markdown
# <project name>

<One paragraph: what this is, stack, the aesthetic/architecture rule
that must never be violated.>

## Mandatory workflow — every change
1. <read-first skill> BEFORE designing
2. <verify command> AFTER building — exercise the change for real
3. <docs-sync skill> — docs updated in the SAME commit
4. <security/quality gate> LAST, before commit

## Quick facts (the always-true list — keep under ~10 lines)
- <build command> is the test suite.
- Adding <content type> = create one file at <path>. Nothing else.
- Never <the one thing that breaks everything>.
```

Rule of thumb: if a line doesn't need to be true in EVERY session,
it belongs in a skill or a knowledge doc, with a pointer here at most.

## 2. A skill (.claude/skills/<name>/SKILL.md) — a procedure with a trigger

```markdown
---
name: sync-docs
description: Update the knowledge/ documentation to match the code
  AFTER making any change — new features, refactors, convention
  changes. Use before committing. A commit that changes behavior
  without updating docs is incomplete.
---

# Documentation Sync

<The full procedure: numbered steps, file-to-doc routing table,
definition of done. This body loads ONLY when the skill is invoked.>
```

Craft rules:
- **Name = action verb.** `sync-docs`, `verify-release`,
  `security-final-check` — never `docs`, `helper`, `misc`.
- **Description = the trigger.** It is the API the agent matches your
  task against; state WHAT it does and WHEN to use it, including the
  words a task would contain. Vague descriptions never fire.
- One skill, one job. A skill that does three things fires wrong for
  two of them.

## 3. The knowledge network (knowledge/*.md) — the repo's long-term memory

```markdown
# INDEX.md
| Doc | Covers | Read before… |
|---|---|---|
| 01-<subsystem>.md | … | any change to … |

## Invariants (never break without a decision entry)
1. <the rules of the architecture, numbered>

## Dependency map
| Subsystem | Depends on | Depended on by |
```

- Present tense, always: describe what IS, delete what no longer is.
  Git history is the changelog; the docs are the state.
- Update in the same commit as the code — the compounding rule. Each
  feature deposits knowledge; the next session starts further ahead.
- Keep an append-only decision log (Decision / Why / Revisit when) for
  judgment calls — the one place history belongs.

## 4. The implementation plan — one feature, reviewed before code

For any multi-phase feature, have the agent produce a plan artifact
first and approve it before code exists (the same confirmation gate as
spec-first image generation):

- [ ] Phases, each independently commit-complete
- [ ] What each phase delivers and how it will be verified
- [ ] The judgment calls made, listed explicitly for your veto
      ("calls I made — flag anything you'd reverse")
- [ ] Permanent decisions flagged (URLs, schemas, names) — these are
      the ones that can't be refactored later
- [ ] Definition of done per phase: build passes, change exercised
      for real, docs synced, gate passed, commit

## The loop, end to end

```
your idea → plan artifact → your approval
  → [agent: read rules/skills → edit → build → verify in the real app]
  → docs synced → gate passed → commit
  → deposits: new/updated skills · knowledge · decisions
  → next feature starts further ahead
```

The tool is only as good as your ideas, and only as powerful as the
hands that mold it. Everything in this kit is a mold.