Add vertical vs horizontal slicing guidance

Adds guidance to prefer vertical slices (user-visible value) over
horizontal slices (technical layers) when planning and writing issues.

roadmap-planning skill:
- New "Vertical vs Horizontal Slices" section
- Demo test: "Can a user demo/test this independently?"
- Good vs bad examples table
- When horizontal slices are acceptable

issue-writing skill:
- New "Vertical Slices" section
- Demo test guidance
- Good vs bad issue titles table
- User-focused issue framing examples

Closes #31

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

CLAUDE.md

@@ -1,20 +1,34 @@
-# Claude Code AI Workflow
+# Architecture
 
-This repository contains configurations, prompts, and tools to improve the Claude Code AI workflow.
+This repository is the organizational source of truth: how we work, who we serve, what we believe, and how we build software with AI.
 
 ## Setup
 
 ```bash
 # Clone and install symlinks
-git clone ssh://git@code.flowmade.one/flowmade-one/ai.git
+git clone ssh://git@code.flowmade.one/flowmade-one/architecture.git
-cd ai
+cd architecture
 make install
 ```
 
+## What This Repo Contains
+
+| Component | Purpose |
+|-----------|---------|
+| `manifesto.md` | Organization vision, personas, beliefs, principles |
+| `learnings/` | Historical record and governance |
+| `commands/` | AI workflow entry points (/work-issue, /manifesto, etc.) |
+| `skills/` | Tool and practice knowledge |
+| `agents/` | Focused subtask handlers |
+| `settings.json` | Claude Code configuration |
+| `Makefile` | Install symlinks to ~/.claude/ |
+
 ## Project Structure
 
 ```
-ai/
+architecture/
+├── manifesto.md    # Organization vision and beliefs
+├── learnings/      # Captured learnings and governance
 ├── commands/       # Slash commands (/work-issue, /dashboard)
 ├── skills/         # Knowledge modules (auto-triggered)
 ├── agents/         # Focused subtask handlers (isolated context)
@@ -25,41 +39,28 @@ ai/
 
 All files symlink to `~/.claude/` via `make install`.
 
-## Architecture
+## Two Levels of Vision
 
-### Skills
+| Level | Document | Command | Purpose |
-Knowledge modules that teach Claude how to do something. Referenced by commands via `@~/.claude/skills/xxx/SKILL.md`.
+|-------|----------|---------|---------|
+| Organization | `manifesto.md` | `/manifesto` | Who we are, shared personas, beliefs |
+| Product | `vision.md` | `/vision` | Product-specific direction and goals |
 
-- **Purpose**: Encode best practices and tool knowledge
+See the manifesto for our identity, personas, and beliefs about AI-augmented development.
-- **Location**: `skills/<name>/SKILL.md`
-- **Usage**: Included in commands for context, auto-triggered by Claude Code
 
-Example: `gitea` skill teaches tea CLI usage, `issue-writing` teaches how to structure issues.
+## Available Commands
 
-### Commands
+| Command | Description |
-User-facing entry points invoked with `/command-name`. Run in main conversation context.
+|---------|-------------|
-
+| `/manifesto` | View/manage organization manifesto |
-- **Purpose**: Orchestrate workflows with user interaction
+| `/vision` | View/manage product vision and milestones |
-- **Location**: `commands/<name>.md`
+| `/work-issue <n>` | Fetch issue, create branch, implement, create PR |
-- **Usage**: User types `/dashboard`, `/work-issue 42`, etc.
+| `/dashboard` | Show open issues and PRs |
-
+| `/review-pr <n>` | Review PR with diff and comments |
-Commands reference skills for knowledge and optionally spawn agents for subtasks.
+| `/create-issue` | Create single or batch issues |
-
+| `/retro` | Capture learnings as issues for encoding |
-### Agents
+| `/plan-issues` | Break down features into issues |
-Small, focused units that handle specific subtasks in isolated context.
+| `/groom` | Improve issue quality |
-
-- **Purpose**: Complex subtasks that benefit from isolation
-- **Location**: `agents/<name>/agent.md`
-- **Usage**: Spawned via Task tool, return results to caller
-
-Good agent candidates:
-- Code review (analyze diff, report issues)
-- Content generation (write issue body, PR description)
-- Analysis tasks (categorize, prioritize, summarize)
-
-**When to use agents vs direct execution:**
-- Use agents when: task is self-contained, benefits from isolation, can run in parallel
-- Use direct execution when: task needs conversation history, requires user interaction mid-task
 
 ## Gitea Integration
 
@@ -73,19 +74,32 @@ tea logins add --name flowmade --url https://git.flowmade.one --token <your-toke
 # Create token at: https://git.flowmade.one/user/settings/applications
 ```
 
-## Available Commands
+## Architecture Components
 
-| Command | Description |
+### Skills
-|---------|-------------|
+Knowledge modules that teach Claude how to do something.
-| `/work-issue <n>` | Fetch issue, create branch, implement, create PR |
-| `/dashboard` | Show open issues and PRs |
-| `/review-pr <n>` | Review PR with diff and comments |
-| `/create-issue` | Create single or batch issues |
-| `/retro` | Capture learnings, create improvement issues |
-| `/vision` | View/manage product vision and milestones |
-| `/plan-issues` | Break down features into issues |
-| `/improve` | Identify gaps between vision and backlog |
 
-## Vision & Goals
+- **Purpose**: Encode best practices and tool knowledge
+- **Location**: `skills/<name>/SKILL.md`
+- **Usage**: Referenced by commands via `@~/.claude/skills/xxx/SKILL.md`
 
-Product vision lives in `vision.md` (philosophy) and Gitea milestones (goals with progress tracking). See `/vision` command.
+### Commands
+User-facing entry points invoked with `/command-name`.
+
+- **Purpose**: Orchestrate workflows with user interaction
+- **Location**: `commands/<name>.md`
+- **Usage**: User types `/dashboard`, `/work-issue 42`, etc.
+
+### Agents
+Focused units that handle specific subtasks in isolated context.
+
+- **Purpose**: Complex subtasks that benefit from isolation
+- **Location**: `agents/<name>/agent.md`
+- **Usage**: Spawned via Task tool, return results to caller
+
+### Learnings
+Captured insights from work, encoded into skills/commands/agents.
+
+- **Purpose**: Historical record + governance + continuous improvement
+- **Location**: `learnings/YYYY-MM-DD-title.md`
+- **Flow**: Retro → Issue → Encode into learning + system update

README.md

@@ -1,4 +1,6 @@
-# Claude Code AI Workflow
+# Architecture
+
+The organizational source of truth: how we work, who we serve, what we believe, and how we build software with AI.
 
 A composable toolkit for enhancing [Claude Code](https://claude.ai/claude-code) with structured workflows, issue management, and AI-assisted development practices.
 
@@ -53,8 +55,8 @@ The project is built around three composable component types:
 
 ```bash
 # Clone the repository
-git clone ssh://git@code.flowmade.one/flowmade-one/ai.git
+git clone ssh://git@code.flowmade.one/flowmade-one/architecture.git
-cd ai
+cd architecture
 
 # Install symlinks to ~/.claude/
 make install
@@ -87,7 +89,9 @@ echo "YOUR_TOKEN" | tea -H code.flowmade.one auth add-key username
 ## Project Structure
 
 ```
-ai/
+architecture/
+├── manifesto.md        # Organization vision, personas, beliefs
+├── learnings/          # Captured learnings and governance
 ├── commands/           # Slash commands invoked by users
 │   ├── work-issue.md
 │   ├── dashboard.md

VISION.md

@@ -1,5 +1,32 @@
 # Vision
 
+This product vision builds on the [organization manifesto](manifesto.md).
+
+## Who This Product Serves
+
+### Flowmade Developers
+
+The team building Flowmade's platform. They need efficient, consistent AI workflows to deliver on the organization's promise: helping domain experts create software without coding.
+
+*Extends: Agencies & Consultancies (from manifesto) - we are our own first customer.*
+
+### AI-Augmented Developers
+
+Developers in the broader community who want to treat AI assistance as a structured tool. They benefit from our "build in public" approach - adopting and adapting our workflows for their own teams.
+
+*Extends: The manifesto's commitment to sharing practices with the developer community.*
+
+## What They're Trying to Achieve
+
+These trace back to organization-level jobs:
+
+| Product Job | Enables Org Job |
+|-------------|-----------------|
+| "Help me work consistently with AI across sessions" | "Help me deliver maintainable solutions to clients faster" |
+| "Help me encode best practices so AI applies them" | "Help me reduce dependency on developers for business process changes" |
+| "Help me manage issues and PRs without context switching" | "Help me deliver maintainable solutions to clients faster" |
+| "Help me capture and share learnings from my work" | (Build in public commitment) |
+
 ## The Problem
 
 AI-assisted development is powerful but inconsistent. Claude Code can help with nearly any task, but without structure:
@@ -9,102 +36,60 @@ AI-assisted development is powerful but inconsistent. Claude Code can help with
 - Context gets lost when switching between tasks
 - There's no shared vocabulary for common patterns
 
-The gap isn't in AI capability—it's in how we use it.
+The gap isn't in AI capability - it's in how we use it.
 
 ## The Solution
 
-This project provides a **composable toolkit** for Claude Code that turns ad-hoc AI assistance into structured, repeatable workflows.
+A **composable toolkit** for Claude Code that turns ad-hoc AI assistance into structured, repeatable workflows.
 
 Instead of asking Claude to "help with issues" differently each time, you run `/work-issue 42` and get a consistent workflow: fetch the issue, create a branch, plan the work, implement, commit with proper references, and create a PR.
 
-The key insight: **encode your team's best practices into reusable components** that Claude can apply consistently.
+### Architecture
 
-## Composable Components
+Three component types that stack together:
 
-The system is built from three types of components that stack together:
+| Component | Purpose | Example |
+|-----------|---------|---------|
+| **Skills** | Knowledge modules - teach Claude how to do something | `gitea`, `issue-writing` |
+| **Agents** | Focused subtask handlers in isolated context | `code-reviewer` |
+| **Commands** | User workflows - orchestrate skills and agents | `/work-issue`, `/dashboard` |
 
-### Skills
+Skills don't act on their own. Agents handle complex subtasks in isolation. Commands are the entry points that tie it together.
 
-Skills are knowledge modules—focused documents that teach Claude how to do something well.
+## Product Principles
 
-Examples:
+These extend the organization's guiding principles:
-- `issue-writing`: How to structure clear, actionable issues
-- `gitea`: How to use the Gitea CLI for issue/PR management
-- `backlog-grooming`: What makes a healthy backlog
-
-Skills don't do anything on their own. They're building blocks.
-
-### Agents
-
-Agents are small, focused units that handle specific subtasks in isolated context.
-
-Unlike commands (which run in the main conversation), agents are spawned via the Task tool to do a specific job and report back. They should be:
-- **Small and focused**: One clear responsibility
-- **Isolated**: Work without needing conversation history
-- **Result-oriented**: Return a specific output (analysis, categorization, generated content)
-
-Examples:
-- `code-reviewer`: Reviews a PR diff and reports issues
-- A hypothetical `categorize-milestone`: Given an issue, determines which milestone it belongs to
-
-Agents enable:
-- **Parallel processing**: Multiple agents can work simultaneously
-- **Context isolation**: Complex subtasks don't pollute the main conversation
-- **Reusability**: Same agent can be spawned by different commands
-
-### Commands
-
-Commands are the user-facing entry points—what you actually invoke.
-
-When you run `/plan-issues add dark mode`, the command:
-1. Understands what you're asking for
-2. References skills for knowledge (how to write issues, use Gitea, etc.)
-3. Optionally spawns agents for complex subtasks
-4. Guides you through the workflow with approvals
-5. Takes action (creates issues, PRs, etc.)
-
-Commands run in the main conversation context, using skills for knowledge and spawning agents only when isolated processing is beneficial.
-
-## Target Users
-
-This toolkit is for:
-
-- **Developers using Claude Code** who want consistent, efficient workflows
-- **Teams** who want to encode and share their best practices
-- **Gitea/Git users** who want seamless issue and PR management integrated into their AI workflow
-
-You should have:
-- Claude Code CLI installed
-- A Gitea instance (or adapt the tooling for GitHub/GitLab)
-- Interest in treating AI assistance as a structured tool, not just a chat interface
-
-## Guiding Principles
-
-### Encode, Don't Repeat
-
-If you find yourself explaining the same thing to Claude repeatedly, that's a skill waiting to be written. Capture it once, use it everywhere.
 
 ### Composability Over Complexity
 
-Small, focused components that combine well beat large, monolithic solutions. A skill should do one thing. An agent should serve one role. A command should trigger one workflow.
+Small, focused components that combine well beat large, monolithic solutions. A skill does one thing. An agent serves one role. A command triggers one workflow.
+
+*Extends: "Small teams, big leverage"*
 
 ### Approval Before Action
 
-Destructive or significant actions should require user approval. Commands should show what they're about to do and ask before doing it. This builds trust and catches mistakes.
+Destructive or significant actions require user approval. Commands show what they're about to do and ask before doing it.
 
-### Use the Tools to Build the Tools
+*Extends: Non-goal "Replacing human judgment"*
 
-This project uses its own commands to manage itself. Issues are created with `/create-issue`. Features are planned with `/plan-issues`. PRs are reviewed with `/review-pr`. Dogfooding ensures the tools actually work.
+### Dogfooding
+
+This project uses its own commands to manage itself. Issues are created with `/create-issue`. PRs are reviewed with `/review-pr`. If the tools don't work for us, they won't work for anyone.
+
+*Extends: "Ship to learn"*
 
 ### Progressive Disclosure
 
-Simple things should be simple. `/dashboard` just shows your issues and PRs. But the system supports complex workflows when you need them. Don't require users to understand the full architecture to get value.
+Simple things should be simple. `/dashboard` just shows your issues and PRs. Complex workflows are available when needed, but not required to get value.
 
-## What This Is Not
+*Extends: "Opinionated defaults, escape hatches available"*
 
-This is not:
+## Non-Goals
-- A replacement for Claude Code—it enhances it
-- A rigid framework—adapt it to your needs
-- Complete—it grows as we discover new patterns
 
-It's a starting point for treating AI-assisted development as a first-class engineering concern.
+These extend the organization's non-goals:
+
+- **Replacing Claude Code.** This enhances Claude Code, not replaces it. The toolkit adds structure; Claude provides the capability.
+
+- **One-size-fits-all workflows.** Teams should adapt these patterns to their needs. We provide building blocks, not a rigid framework.
+
+- **Feature completeness.** The toolkit grows as we discover new patterns. It's a starting point, not an end state.

agents/code-reviewer/AGENT.md

@@ -5,6 +5,9 @@ description: Automated code review of pull requests. Reviews PRs for quality, bu
 # The structured output format doesn't require opus-level reasoning.
 model: sonnet
 skills: gitea, code-review
+disallowedTools:
+  - Edit
+  - Write
 ---
 
 You are a code review specialist that provides immediate, structured feedback on pull request changes.

commands/create-repo.md

@@ -0,0 +1,208 @@
+---
+description: Create a new repository with standard structure. Scaffolds vision.md, CLAUDE.md, and CI configuration.
+argument-hint: <repo-name>
+context: fork
+---
+
+# Create Repository
+
+@~/.claude/skills/repo-conventions/SKILL.md
+@~/.claude/skills/vision-management/SKILL.md
+@~/.claude/skills/claude-md-writing/SKILL.md
+@~/.claude/skills/gitea/SKILL.md
+
+Create a new repository with Flowmade's standard structure.
+
+## Process
+
+1. **Get repository name**: Use `$1` or ask the user
+   - Validate: lowercase, hyphens only, no `flowmade-` prefix
+   - Check it doesn't already exist: `tea repos flowmade-one/<name>`
+
+2. **Determine visibility**:
+   - Ask: "Should this repo be public (open source) or private (proprietary)?"
+   - Refer to repo-conventions skill for guidance on open vs proprietary
+
+3. **Gather vision context**:
+   - Read the organization manifesto: `../architecture/manifesto.md`
+   - Ask: "What does this product do? (one sentence)"
+   - Ask: "Which manifesto personas does it serve?"
+   - Ask: "What problem does it solve?"
+
+4. **Create the repository on Gitea**:
+   ```bash
+   tea repos create --name <repo-name> --private/--public --description "<description>"
+   ```
+
+5. **Clone and set up structure**:
+   ```bash
+   # Clone the new repo
+   git clone ssh://git@git.flowmade.one/flowmade-one/<repo-name>.git
+   cd <repo-name>
+   ```
+
+6. **Create vision.md**:
+   - Use the vision structure template from vision-management skill
+   - Link to `../architecture/manifesto.md`
+   - Fill in based on user's answers
+
+7. **Create CLAUDE.md** (following claude-md-writing skill):
+   ```markdown
+   # <Repo Name>
+
+   <One-line description from step 3>
+
+   ## Organization Context
+
+   This repo is part of Flowmade. See:
+   - [Organization manifesto](../architecture/manifesto.md) - who we are, what we believe
+   - [Repository map](../architecture/repos.md) - how this fits in the bigger picture
+   - [Vision](./vision.md) - what this specific product does
+
+   ## Setup
+
+   ```bash
+   # TODO: Add setup instructions
+   ```
+
+   ## Project Structure
+
+   TODO: Document key directories once code exists.
+
+   ## Development
+
+   ```bash
+   make build    # Build the project
+   make test     # Run tests
+   make lint     # Run linters
+   ```
+
+   ## Architecture
+
+   TODO: Document key patterns and conventions once established.
+   ```
+
+8. **Create Makefile** (basic template):
+   ```makefile
+   .PHONY: build test lint
+
+   build:
+   	@echo "TODO: Add build command"
+
+   test:
+   	@echo "TODO: Add test command"
+
+   lint:
+   	@echo "TODO: Add lint command"
+   ```
+
+9. **Create CI workflow**:
+   ```bash
+   mkdir -p .gitea/workflows
+   ```
+
+   Create `.gitea/workflows/ci.yaml`:
+   ```yaml
+   name: CI
+   on:
+     push:
+       branches: [main]
+     pull_request:
+       branches: [main]
+
+   jobs:
+     build:
+       runs-on: ubuntu-latest
+       steps:
+         - uses: actions/checkout@v4
+         - name: Build
+           run: make build
+         - name: Test
+           run: make test
+         - name: Lint
+           run: make lint
+   ```
+
+10. **Create .gitignore** (basic, expand based on language):
+    ```
+    # IDE
+    .idea/
+    .vscode/
+    *.swp
+
+    # OS
+    .DS_Store
+    Thumbs.db
+
+    # Build artifacts
+    /dist/
+    /build/
+    /bin/
+
+    # Dependencies (language-specific, add as needed)
+    /node_modules/
+    /vendor/
+    ```
+
+11. **Initial commit and push**:
+    ```bash
+    git add .
+    git commit -m "Initial repository structure
+
+    - vision.md linking to organization manifesto
+    - CLAUDE.md with project instructions
+    - CI workflow template
+    - Basic Makefile
+
+    🤖 Generated with [Claude Code](https://claude.com/claude-code)
+
+    Co-Authored-By: Claude <noreply@anthropic.com>"
+
+    git push -u origin main
+    ```
+
+12. **Report success**:
+    ```
+    Repository created: https://git.flowmade.one/flowmade-one/<repo-name>
+
+    Next steps:
+    1. cd ../<repo-name>
+    2. Update CLAUDE.md with actual setup instructions
+    3. Update Makefile with real build commands
+    4. Start building!
+    ```
+
+## Output Example
+
+```
+## Creating Repository: my-service
+
+Visibility: Private (proprietary)
+Description: Internal service for processing events
+
+### Files Created
+
+- vision.md (linked to manifesto)
+- CLAUDE.md (project instructions)
+- Makefile (build template)
+- .gitea/workflows/ci.yaml (CI pipeline)
+- .gitignore (standard ignores)
+
+### Repository URL
+
+https://git.flowmade.one/flowmade-one/my-service
+
+### Next Steps
+
+1. cd ../my-service
+2. Update CLAUDE.md with setup instructions
+3. Update Makefile with build commands
+4. Start coding!
+```
+
+## Guidelines
+
+- Always link vision.md to the sibling architecture repo
+- Keep initial structure minimal - add complexity as needed
+- CI should pass on empty repo (use placeholder commands)
+- Default to private unless explicitly open-sourcing

commands/improve.md

@@ -1,5 +1,7 @@
 ---
 description: Identify improvement opportunities based on product vision. Analyzes gaps between vision goals and current backlog.
+argument-hint:
+context: fork
 ---
 
 # Improvement Analysis

commands/manifesto.md

@@ -1,5 +1,6 @@
 ---
 description: View and manage the organization manifesto. Shows identity, personas, beliefs, and principles.
+argument-hint:
 ---
 
 # Organization Manifesto

commands/plan-issues.md

@@ -1,6 +1,7 @@
 ---
 description: Plan and create issues for a feature or improvement. Breaks down work into well-structured issues with vision alignment.
 argument-hint: <feature-description>
+context: fork
 ---
 
 # Plan Feature: $1

commands/retro.md

@@ -1,15 +1,23 @@
 ---
-description: Run a retrospective on completed work. Captures learnings, creates improvement issues, and updates product vision.
+description: Run a retrospective on completed work. Captures insights as issues for later encoding into skills/commands/agents.
 argument-hint: [task-description]
 ---
 
 # Retrospective
 
-Capture learnings from completed work. Learnings are stored for historical record and governance, then encoded into skills/commands/agents where Claude can use them.
+Capture insights from completed work as issues on the architecture repo. Issues are later encoded into learnings and skills/commands/agents.
 
 @~/.claude/skills/vision-management/SKILL.md
 @~/.claude/skills/gitea/SKILL.md
 
+## Flow
+
+```
+Retro (any repo) → Issue (architecture repo) → Encode: learning file + skill/command/agent
+```
+
+The retro creates the issue. Encoding happens when the issue is worked on.
+
 ## Process
 
 1. **Gather context**: If $1 is provided, use it as the task description. Otherwise, ask the user what task was just completed.
@@ -19,99 +27,81 @@ Capture learnings from completed work. Learnings are stored for historical recor
    - What worked well?
    - Any specific improvement ideas?
 
-3. **Identify learnings**: For each insight, determine:
+3. **Identify insights**: For each insight, determine:
    - **What was learned**: The specific insight
    - **Where to encode it**: Which skill, command, or agent should change?
    - **Governance impact**: What does this mean for how we work?
 
-4. **Store the learning**: Create a learning file in the architecture repo:
+4. **Create issue on architecture repo**: Always create issues on `flowmade-one/architecture`:
 
-   **File**: `learnings/YYYY-MM-DD-short-title.md`
+   ```bash
+   tea issues create -r flowmade-one/architecture \
+     --title "[Learning] <brief description>" \
+     --description "## Context
+   [Task that triggered this insight]
+
+   ## Insight
+   [The specific learning - be concrete and actionable]
+
+   ## Suggested Encoding
+   - [ ] \`skills/xxx/SKILL.md\` - [what to add/change]
+   - [ ] \`commands/xxx.md\` - [what to add/change]
+   - [ ] \`agents/xxx/agent.md\` - [what to add/change]
+
+   ## Governance
+   [What this means for how we work going forward]"
+   ```
+
+5. **Connect to vision**: Check if insight affects vision:
+   - **Architecture repo**: Does this affect `manifesto.md`? (beliefs, principles, non-goals)
+   - **Product repo**: Does this affect `vision.md`? (product direction, goals)
+
+   If vision updates are needed, present suggested changes and ask for approval.
+
+## When the Issue is Worked On
+
+When encoding a learning issue, the implementer should:
+
+1. **Create learning file**: `learnings/YYYY-MM-DD-short-title.md`
 
    ```markdown
    # [Learning Title]
 
    **Date**: YYYY-MM-DD
    **Context**: [Task that triggered this learning]
+   **Issue**: #XX
 
    ## Learning
 
-   [The specific insight - be concrete and actionable]
+   [The specific insight]
 
    ## Encoded In
 
-   - Pending: Issue #XX to update [target skill/command/agent]
+   - `skills/xxx/SKILL.md` - [what was added/changed]
+   - `commands/xxx.md` - [what was added/changed]
 
    ## Governance
 
-   [What this means for how we work going forward]
+   [What this means for how we work]
    ```
 
-   ```bash
+2. **Update skill/command/agent** with the encoded knowledge
-   # Create the learning file in architecture repo
-   # If in architecture repo:
-   cat > learnings/YYYY-MM-DD-short-title.md << 'EOF'
-   [content]
-   EOF
 
-   # If in a different repo, note that learning should be added to architecture repo
+3. **Close the issue** with reference to the learning file and changes made
-   ```
-
-5. **Create encoding issue**: Create an issue to encode the learning:
-
-   ```bash
-   tea issues create -r flowmade-one/ai \
-     --title "Encode learning: [brief description]" \
-     --description "## Learning Reference
-   See: learnings/YYYY-MM-DD-short-title.md
-
-   ## What to Encode
-   [The specific change to make]
-
-   ## Target
-   - [ ] \`skills/xxx/SKILL.md\` - [what to add/change]
-   - [ ] \`commands/xxx.md\` - [what to add/change]
-
-   ## Governance
-   [Why this matters]"
-   ```
-
-6. **Update learning file**: Add the issue reference to the "Encoded In" section.
-
-7. **Connect to vision**: Check if learning affects vision:
-   - **Architecture repo**: Does this affect `manifesto.md`? (beliefs, principles, non-goals)
-   - **Product repo**: Does this affect `vision.md`? (product direction, goals)
-
-   If vision updates are needed:
-   - Present suggested changes
-   - Ask for approval
-   - Update the appropriate file
 
 ## Encoding Destinations
 
-| Learning Type | Encode In |
+| Insight Type | Encode In |
-|---------------|-----------|
+|--------------|-----------|
 | How to use a tool | `skills/[tool]/SKILL.md` |
 | Workflow improvement | `commands/[command].md` |
 | Subtask behavior | `agents/[agent]/agent.md` |
 | Organization belief | `manifesto.md` |
 | Product direction | `vision.md` (in product repo) |
 
-## Architecture vs Product Repos
-
-**In the architecture repo**:
-- Learning files are created directly in `learnings/`
-- Issues are created in the same repo
-- Vision changes affect `manifesto.md`
-
-**In product repos**:
-- Learning files should be added to the architecture repo (not the product repo)
-- Issues are created in `flowmade-one/ai` (architecture repo)
-- Local vision changes affect `vision.md` in the product repo
-
 ## Labels
 
-Add appropriate labels to encoding issues:
+Add appropriate labels to issues:
 - `learning` - Always add this
 - `prompt-improvement` - For command/skill text changes
 - `new-feature` - For new commands/skills/agents
@@ -119,8 +109,8 @@ Add appropriate labels to encoding issues:
 
 ## Guidelines
 
-- **Be specific**: Vague learnings can't be encoded
+- **Always create issues on architecture repo** - regardless of which repo the retro runs in
-- **One learning per file**: Don't bundle unrelated insights
+- **Be specific**: Vague insights can't be encoded
-- **Always encode**: A learning without encoding is just documentation
+- **One issue per insight**: Don't bundle unrelated things
-- **Reference both ways**: Learning file → Issue, Issue → Learning file
+- **Encoding happens later**: Retro captures the issue, encoding is separate work
-- **Skip one-offs**: Don't capture learnings for edge cases that won't recur
+- **Skip one-offs**: Don't capture insights for edge cases that won't recur

commands/roadmap.md

@@ -1,5 +1,6 @@
 ---
 description: View current issues as a roadmap. Shows open issues organized by status and dependencies.
+argument-hint:
 ---
 
 # Roadmap View

commands/update-claude-md.md

@@ -0,0 +1,166 @@
+---
+description: Update or create CLAUDE.md with current project context. Explores the project and ensures organization context is present.
+argument-hint:
+context: fork
+---
+
+# Update CLAUDE.md
+
+@~/.claude/skills/claude-md-writing/SKILL.md
+@~/.claude/skills/repo-conventions/SKILL.md
+
+Update or create CLAUDE.md for the current repository with proper organization context and current project state.
+
+## Process
+
+1. **Check for existing CLAUDE.md**: Look for `CLAUDE.md` in repo root
+
+2. **If CLAUDE.md exists**:
+   - Read current content
+   - Identify which sections exist
+   - Note any custom content to preserve
+
+3. **Explore the project**:
+   - Scan directory structure
+   - Identify language/framework (go.mod, package.json, Cargo.toml, etc.)
+   - Find key patterns (look for common directories, config files)
+   - Check for Makefile or build scripts
+
+4. **Check organization context**:
+   - Does it have the "Organization Context" section?
+   - Does it link to `../architecture/manifesto.md`?
+   - Does it link to `../architecture/repos.md`?
+   - Does it link to `./vision.md`?
+
+5. **Gather missing information**:
+   - If no one-line description: Ask user
+   - If no architecture section: Infer from code or ask user
+
+6. **Update CLAUDE.md**:
+
+   **Always ensure these sections exist:**
+
+   ```markdown
+   # [Project Name]
+
+   [One-line description]
+
+   ## Organization Context
+
+   This repo is part of Flowmade. See:
+   - [Organization manifesto](../architecture/manifesto.md) - who we are, what we believe
+   - [Repository map](../architecture/repos.md) - how this fits in the bigger picture
+   - [Vision](./vision.md) - what this specific product does
+
+   ## Setup
+
+   [From existing or ask user]
+
+   ## Project Structure
+
+   [Generate from actual directory scan]
+
+   ## Development
+
+   [From Makefile or existing]
+
+   ## Architecture
+
+   [From existing or infer from code patterns]
+   ```
+
+7. **Preserve custom content**:
+   - Keep any additional sections the user added
+   - Don't remove information, only add/update
+   - If unsure, ask before removing
+
+8. **Show diff and confirm**:
+   - Show what will change
+   - Ask user to confirm before writing
+
+## Section-Specific Guidance
+
+### Project Structure
+
+Generate from actual directory scan:
+```bash
+# Scan top-level and key subdirectories
+ls -la
+ls pkg/ cmd/ internal/ src/ (as applicable)
+```
+
+Format as tree showing purpose:
+```markdown
+## Project Structure
+
+\`\`\`
+project/
+├── cmd/           # Entry points
+├── pkg/           # Shared packages
+│   ├── domain/    # Business logic
+│   └── infra/     # Infrastructure
+└── internal/      # Private packages
+\`\`\`
+```
+
+### Development Commands
+
+Extract from Makefile if present:
+```bash
+grep -E "^[a-zA-Z_-]+:" Makefile | head -10
+```
+
+Or from package.json scripts, Cargo.toml, etc.
+
+### Architecture
+
+Look for patterns:
+- Event sourcing: Check for aggregates, events, projections
+- Clean architecture: Check for domain, application, infrastructure layers
+- API style: REST, gRPC, GraphQL
+
+If unsure, ask: "What are the key architectural patterns in this project?"
+
+## Output Example
+
+```
+## Updating CLAUDE.md
+
+### Current State
+- Has description: ✓
+- Has org context: ✗ (will add)
+- Has setup: ✓
+- Has structure: Outdated (will update)
+- Has development: ✓
+- Has architecture: ✗ (will add)
+
+### Changes
+
++ Adding Organization Context section
+~ Updating Project Structure (new directories found)
++ Adding Architecture section
+
+### New Project Structure
+
+\`\`\`
+arcadia/
+├── cmd/
+├── pkg/
+│   ├── aether/      # Event sourcing runtime
+│   ├── iris/        # WASM UI framework
+│   ├── adl/         # Domain language
+│   └── ...
+└── internal/
+\`\`\`
+
+Proceed with update? [y/n]
+```
+
+## Guidelines
+
+- Always add Organization Context if missing
+- Preserve existing custom sections
+- Update Project Structure from actual filesystem
+- Don't guess at Architecture - ask if unclear
+- Show changes before writing
+- Reference claude-md-writing skill for best practices

commands/vision.md

@@ -18,30 +18,75 @@ This command manages **product-level** vision. For organization-level vision, us
 | **Product** | `vision.md` | Product-specific personas, jobs, solution | `/vision` |
 | **Goals** | Gitea milestones | Measurable progress toward vision | `/vision goals` |
 
-Product vision inherits from and extends the organization manifesto.
+Product vision **inherits from and extends** the organization manifesto - it should never duplicate.
+
+## Manifesto Location
+
+The manifesto lives in the sibling `architecture` repo:
+
+```
+org/
+├── architecture/
+│   └── manifesto.md    ← organization manifesto
+├── product-a/
+│   └── vision.md       ← extends ../architecture/manifesto.md
+└── product-b/
+    └── vision.md
+```
+
+Look for manifesto in this order:
+1. `./manifesto.md` (if this IS the architecture repo)
+2. `../architecture/manifesto.md` (sibling repo)
 
 ## Process
 
-1. **Check for organization manifesto**: Note if `manifesto.md` exists (provides org context)
+1. **Load organization context**: Find and read `manifesto.md` using the location rules above
+   - Extract personas (Who We Serve)
+   - Extract jobs to be done (What They're Trying to Achieve)
+   - Extract guiding principles
+   - Extract non-goals
+   - If not found, warn and continue without inheritance context
 
 2. **Check for product vision**: Look for `vision.md` in the current repo root
 
 3. **If no vision exists**:
-   - Reference the organization manifesto if it exists
+   - Show the organization manifesto summary
    - Ask if the user wants to create a product vision
-   - Guide them through defining:
+   - Guide them through defining (with inheritance):
-     1. **Product personas**: Who does this product serve? (may extend org personas)
+
-     2. **Product jobs**: What specific jobs does this product address?
+     **Who This Product Serves**
-     3. **The problem**: What pain points does this product solve?
+     - Show manifesto personas first
-     4. **The solution**: How does this product address those jobs?
+     - Ask: "Which personas does this product serve? How does it extend or specialize them?"
-     5. **Product principles**: Any product-specific principles (beyond org principles)?
+     - Product personas should reference org personas with product-specific context
-     6. **Product non-goals**: What is this product explicitly NOT doing?
+
-   - Create `vision.md`
+     **What They're Trying to Achieve**
+     - Show manifesto jobs first
+     - Ask: "What product-specific jobs does this enable? How do they trace back to org jobs?"
+     - Use a table format showing the connection
+
+     **The Problem**
+     - What pain points does this product solve?
+
+     **The Solution**
+     - How does this product address those jobs?
+
+     **Product Principles**
+     - Show manifesto principles first
+     - Ask: "Any product-specific principles? These should extend, not duplicate."
+     - Each principle should note what org principle it extends
+
+     **Product Non-Goals**
+     - Show manifesto non-goals first
+     - Ask: "Any product-specific non-goals?"
+     - Org non-goals apply automatically
+
+   - Create `vision.md` with proper inheritance markers
    - Ask about initial goals, create as Gitea milestones
 
 4. **If vision exists**:
-   - Display organization context (if manifesto exists)
+   - Display organization context summary
    - Display the product vision from `vision.md`
+   - Validate inheritance (warn if vision duplicates rather than extends)
    - Show current milestones and their progress: `tea milestones`
    - Check if `$1` specifies an action:
      - `goals`: Manage milestones (add, close, view progress)
@@ -64,47 +109,101 @@ Success: <criteria>"
    tea milestones close <milestone-name>
    ```
 
+## Vision Structure Template
+
+```markdown
+# Vision
+
+This product vision builds on the [organization manifesto](../architecture/manifesto.md).
+
+## Who This Product Serves
+
+### [Persona Name]
+
+[Product-specific description]
+
+*Extends: [Org persona] (from manifesto)*
+
+## What They're Trying to Achieve
+
+These trace back to organization-level jobs:
+
+| Product Job | Enables Org Job |
+|-------------|-----------------|
+| "[Product-specific job]" | "[Org job from manifesto]" |
+
+## The Problem
+
+[Pain points this product addresses]
+
+## The Solution
+
+[How this product solves those problems]
+
+## Product Principles
+
+These extend the organization's guiding principles:
+
+### [Principle Name]
+
+[Description]
+
+*Extends: "[Org principle]"*
+
+## Non-Goals
+
+These extend the organization's non-goals:
+
+- **[Non-goal].** [Explanation]
+```
+
 ## Output Format
 
 ```
 ## Organization Context
 
-See manifesto for shared personas, beliefs, and principles.
+From manifesto.md:
-[Link or note about manifesto.md location]
+- **Personas**: [list from manifesto]
+- **Core beliefs**: [key beliefs]
+- **Principles**: [list]
 
 ## Product: [Name]
 
 ### Who This Product Serves
 
 - **[Persona 1]**: [Product-specific description]
-- **[Persona 2]**: [Product-specific description]
+  ↳ Extends: [Org persona]
 
 ### What They're Trying to Achieve
 
-- "[Product-specific job 1]"
+| Product Job | → Org Job |
-- "[Product-specific job 2]"
+|-------------|-----------|
+| [job] | [org job it enables] |
 
-### Product Vision
+### Vision Summary
 
-[Summary of problem/solution from vision.md]
+[Problem/solution from vision.md]
 
 ### Goals (Milestones)
 
 | Goal | For | Progress | Due |
 |------|-----|----------|-----|
 | [title] | [Persona] | 3/5 issues | [date] |
-
-### Current Focus
-
-[Open milestones with nearest due dates or most activity]
 ```
 
+## Inheritance Rules
+
+- **Personas**: Product personas extend org personas with product-specific context
+- **Jobs**: Product jobs trace back to org-level jobs (show the connection)
+- **Beliefs**: Inherited from manifesto, never duplicated in vision
+- **Principles**: Product adds specific principles that extend org principles
+- **Non-Goals**: Product adds its own; org non-goals apply automatically
+
 ## Guidelines
 
-- Product vision builds on organization manifesto - don't duplicate, extend
+- Product vision builds on organization manifesto - extend, don't duplicate
-- Product personas can be more specific versions of org personas
+- Every product persona should reference which org persona it extends
-- Product jobs should trace back to org-level jobs to be done
+- Every product job should show which org job it enables
-- Milestones are product-specific goals toward the vision
+- Product principles should note which org principle they extend
 - Use `/manifesto` for organization-level identity and beliefs
 - Use `/vision` for product-specific direction and goals
-- If this is the architecture repo itself, use `/manifesto` instead

docs/writing-agents.md

@@ -67,6 +67,90 @@ All sections are important:
 - **When to Use**: Prevents misuse and guides selection
 - **Behavior**: Sets expectations for operation
 
+## YAML Frontmatter
+
+Agent files support YAML frontmatter for configuration. While the body content defines the agent's personality and instructions, frontmatter controls its technical behavior.
+
+### Required Fields
+
+| Field | Description |
+|-------|-------------|
+| `name` | Agent identifier (lowercase, hyphens). Should match directory name. |
+| `description` | What the agent does. Used for matching when spawning agents. |
+
+### Optional Fields
+
+| Field | Description |
+|-------|-------------|
+| `model` | Model to use: `haiku`, `sonnet`, `opus`, or `inherit` (default). |
+| `skills` | Comma-separated list of skills the agent can access. |
+| `disallowedTools` | Explicitly block specific tools from this agent. |
+| `permissionMode` | Permission behavior: `default`, `bypassPermissions`, or custom. |
+| `hooks` | Define PreToolUse, PostToolUse, or Stop hooks scoped to this agent. |
+
+### Example Frontmatter
+
+**Basic agent:**
+```yaml
+---
+name: code-reviewer
+description: Review code for quality, bugs, and style issues.
+model: sonnet
+skills: gitea, code-review
+---
+```
+
+**Agent with tool restrictions:**
+```yaml
+---
+name: read-only-analyst
+description: Analyze code without making changes.
+model: haiku
+skills: code-review
+disallowedTools:
+  - Edit
+  - Write
+  - Bash
+---
+```
+
+**Agent with hooks:**
+```yaml
+---
+name: database-admin
+description: Manage database operations safely.
+model: opus
+hooks:
+  - type: PreToolUse
+    matcher: Bash
+    command: echo "Validating database command..."
+  - type: Stop
+    command: echo "Database operation completed"
+---
+```
+
+### Permission Modes
+
+The `permissionMode` field controls how the agent handles tool permissions:
+
+| Mode | Behavior |
+|------|----------|
+| `default` | Inherits parent's permission settings (standard behavior) |
+| `bypassPermissions` | Skip permission prompts (use for trusted, well-tested agents) |
+
+Use `bypassPermissions` sparingly—only for agents that are thoroughly tested and operate within safe boundaries.
+
+## Built-in Agents
+
+Claude Code provides built-in agents that you can leverage instead of creating custom ones:
+
+| Agent | Purpose | When to Use |
+|-------|---------|-------------|
+| **Explore** | Codebase exploration and search | Finding files, understanding structure, searching code. Powered by Haiku for efficiency. |
+| **Plan** | Implementation planning | Designing approaches, breaking down tasks, architectural decisions. |
+
+Consider using built-in agents before creating custom ones—they're optimized for common tasks.
+
 ## How Agents Combine Skills
 
 Agents gain their expertise by combining multiple skills. Each skill contributes domain knowledge to the agent's overall capability.
@@ -187,6 +271,28 @@ Agents can explore codebases independently, building understanding without pollu
 - Exploration might involve many file reads and searches
 - Results should be summarized, not shown in full
 
+### 5. Background Execution
+
+Agents can run in the background while you continue working. Background agents execute asynchronously and notify the main thread when complete.
+
+```
+User working                    Background Agent
+┌─────────────────┐            ┌─────────────────┐
+│ Continue coding │            │ Running tests   │
+│ on feature      │            │ in background   │
+│                 │            │                 │
+│ (not blocked)   │   notify   │ (async work)    │
+│                 │ ◄───────── │                 │
+└─────────────────┘            └─────────────────┘
+```
+
+**Use when:**
+- Task is long-running (test suites, large codebase analysis)
+- You want to continue working while the agent operates
+- Results are needed later, not immediately
+
+Background agents can send messages to wake up the main agent when they have results or need attention.
+
 ## When to Use an Agent vs Direct Skill Invocation
 
 ### Use Direct Skill Invocation When:
@@ -573,14 +679,26 @@ Improve based on usage:
 
 ## Checklist: Before Submitting a New Agent
 
+### Structure
 - [ ] File is at `agents/<name>/AGENT.md`
 - [ ] Name follows kebab-case convention
 - [ ] Agent has a clear, recognizable role
-- [ ] Skills list is deliberate (not too many, not too few)
+
-- [ ] Model selection is deliberate (not just `inherit` by default)
+### Frontmatter
+- [ ] `name` and `description` fields are set
+- [ ] `model` selection is deliberate (not just `inherit` by default)
+- [ ] `skills` list is deliberate (not too many, not too few)
+- [ ] Consider `disallowedTools` if agent should be restricted
+- [ ] Consider `permissionMode` for trusted agents
+- [ ] Consider `hooks` for validation or logging
+
+### Content
 - [ ] Capabilities are specific and achievable
 - [ ] "When to Use" guidance is clear
 - [ ] Behavioral rules prevent problems
+
+### Integration
+- [ ] Consider if built-in agents (Explore, Plan) could be used instead
 - [ ] Agent is referenced by at least one command
 - [ ] ARCHITECTURE.md is updated
 

docs/writing-commands.md

@@ -43,10 +43,21 @@ argument-hint: <required-arg> [optional-arg]
 ---
 ```
 
-| Field | Purpose | Required |
+#### Required Fields
-|-------|---------|----------|
+
-| `description` | One-line summary for help/listings | Yes |
+| Field | Purpose |
-| `argument-hint` | Shows expected arguments | If arguments needed |
+|-------|---------|
+| `description` | One-line summary for help/listings |
+
+#### Optional Fields
+
+| Field | Purpose |
+|-------|---------|
+| `argument-hint` | Shows expected arguments (e.g., `<issue-number>`, `[title]`) |
+| `model` | Model to use: `haiku`, `sonnet`, `opus`. Overrides session default. |
+| `context` | Execution context. Use `fork` to run in isolated sub-agent context. |
+| `hooks` | Define PreToolUse, PostToolUse, or Stop hooks scoped to this command. |
+| `allowed-tools` | Restrict which tools the command can use. |
 
 ### 2. Body (Markdown Instructions)
 
@@ -83,6 +94,50 @@ argument-hint: <issue-number>
 7. **Create PR** with title "[Issue #$1] <title>" and body "Closes #$1"
 ```
 
+## Advanced Frontmatter Examples
+
+**Command with specific model:**
+```yaml
+---
+description: Plan complex feature implementation.
+argument-hint: <feature-description>
+model: opus
+---
+```
+
+**Command with isolated context (prevents context pollution):**
+```yaml
+---
+description: Analyze codebase architecture deeply.
+context: fork
+model: haiku
+---
+```
+
+**Command with hooks:**
+```yaml
+---
+description: Deploy to production environment.
+hooks:
+  - type: PreToolUse
+    matcher: Bash
+    command: echo "Validating deployment command..."
+  - type: Stop
+    command: ./scripts/notify-deployment.sh
+---
+```
+
+**Read-only command with tool restrictions:**
+```yaml
+---
+description: Generate codebase report without modifications.
+allowed-tools:
+  - Read
+  - Glob
+  - Grep
+---
+```
+
 ## Argument Handling
 
 Commands can accept arguments from the user. Arguments are passed via positional variables: `$1`, `$2`, etc.
@@ -643,16 +698,29 @@ Update references:
 
 ## Checklist: Before Submitting a New Command
 
+### Structure
 - [ ] File is at `commands/<name>.md`
 - [ ] Name follows kebab-case verb convention
-- [ ] Frontmatter includes description
+
-- [ ] Frontmatter includes argument-hint (if arguments needed)
+### Frontmatter (Required)
+- [ ] `description` is set with clear one-line summary
+- [ ] `argument-hint` is set (if command takes arguments)
+
+### Frontmatter (Consider)
+- [ ] `model` if command benefits from specific model (e.g., `opus` for complex planning)
+- [ ] `context: fork` if command does heavy exploration that would pollute context
+- [ ] `allowed-tools` if command should be restricted to certain tools
+- [ ] `hooks` if command needs validation or post-execution actions
+
+### Content
 - [ ] Workflow steps are clear and numbered
 - [ ] Commands and tools are specified explicitly
 - [ ] Skills are included via `@~/.claude/skills/<name>/SKILL.md` file references
 - [ ] Approval points exist before significant actions
 - [ ] Edge cases are handled (no data, invalid input)
 - [ ] Output formatting is specified
+
+### Integration
 - [ ] ARCHITECTURE.md is updated with new command
 
 ## See Also

docs/writing-skills.md

@@ -29,8 +29,12 @@ Every `SKILL.md` file **must** start with YAML frontmatter. This is how Claude d
 
 | Field | Description |
 |-------|-------------|
-| `allowed-tools` | **Restricts** which tools Claude can use when this skill is active. If omitted, no restrictions apply. |
+| `allowed-tools` | **Restricts** which tools Claude can use when this skill is active. If omitted, no restrictions apply. Supports YAML-style lists. |
-| `model` | Specific model to use when skill is active (e.g., `claude-sonnet-4-20250514`). |
+| `model` | Specific model to use when skill is active (e.g., `sonnet`, `opus`, `haiku`). |
+| `user-invocable` | Whether the skill appears in the `/` command menu. Defaults to `true`. Set to `false` for reference-only skills. |
+| `context` | Execution context. Use `fork` to run skill in an isolated sub-agent context, preventing context pollution. |
+| `agent` | Agent type to use for execution. Allows skills to specify which agent handles them. |
+| `hooks` | Define PreToolUse, PostToolUse, or Stop hooks scoped to this skill's lifecycle. |
 
 ### Writing Effective Descriptions
 
@@ -55,6 +59,7 @@ description: View, create, and manage Gitea issues and pull requests using tea C
 ---
 name: gitea
 description: View, create, and manage Gitea issues and pull requests using tea CLI. Use when working with issues, PRs, viewing issue details, creating pull requests, or when the user mentions tea, gitea, or issue numbers.
+user-invocable: false
 ---
 
 # Gitea CLI (tea)
@@ -62,6 +67,51 @@ description: View, create, and manage Gitea issues and pull requests using tea C
 [Rest of skill content...]
 ```
 
+### Advanced Frontmatter Examples
+
+**Reference skill (not directly invocable):**
+```yaml
+---
+name: gitea
+description: CLI reference for Gitea operations.
+user-invocable: false
+---
+```
+
+**Skill with isolated context:**
+```yaml
+---
+name: codebase-analysis
+description: Deep codebase exploration and analysis.
+context: fork
+model: haiku
+---
+```
+
+**Skill with tool restrictions (YAML-style list):**
+```yaml
+---
+name: read-only-review
+description: Code review without modifications.
+allowed-tools:
+  - Read
+  - Glob
+  - Grep
+---
+```
+
+**Skill with hooks:**
+```yaml
+---
+name: database-operations
+description: Database schema and migration operations.
+hooks:
+  - type: PreToolUse
+    matcher: Bash
+    command: echo "Validating database command..."
+---
+```
+
 ## Subagents and Skills
 
 Subagents **do not automatically inherit skills** from the main conversation. To give a subagent access to skills, list them in the agent's `skills` field:
@@ -153,6 +203,14 @@ Skills are **model-invoked**: Claude decides which skills to use based on your r
 2. **On request**: Claude matches your request against skill descriptions using semantic similarity
 3. **Activation**: When a match is found, Claude asks to use the skill before loading the full content
 
+### Hot Reload
+
+Skills support **automatic hot-reload**. When you create or modify a skill file in `~/.claude/skills/` or `.claude/skills/`, the changes are immediately available without restarting Claude Code. This enables rapid iteration when developing skills.
+
+### Visibility in Command Menu
+
+By default, skills in `/skills/` directories appear in the `/` slash command menu. Users can invoke them directly like commands. To hide a skill from the menu (e.g., for reference-only skills), add `user-invocable: false` to the frontmatter.
+
 ### Subagent Access
 
 Subagents (defined in `.claude/agents/`) must explicitly list which skills they can use:
@@ -493,6 +551,13 @@ Keep skills current:
 - [ ] `description` lists specific capabilities
 - [ ] `description` includes "Use when..." with trigger terms
 
+### Optional Frontmatter (Consider)
+- [ ] `user-invocable: false` if skill is reference-only (e.g., CLI docs)
+- [ ] `context: fork` if skill does heavy exploration that would pollute context
+- [ ] `model` if skill benefits from a specific model (e.g., `haiku` for speed)
+- [ ] `allowed-tools` if skill should be restricted to certain tools
+- [ ] `hooks` if skill needs validation or logging
+
 ### File Structure
 - [ ] File is at `skills/<name>/SKILL.md`
 - [ ] Name follows kebab-case convention

manifesto.md

@@ -2,32 +2,41 @@
 
 ## Who We Are
 
-We are a small, focused team of AI-native builders. We believe the future of software development is human-AI collaboration, and we're building the tools and practices to make that real.
+We are a small, focused team building tools that make work easier. We believe software should support business processes without requiring everyone to become a developer. We build in public - sharing our AI-augmented development practices, tools, and learnings with the developer community.
-
-We move fast with intention. We value quality over quantity. We encode our knowledge into systems that amplify what we can accomplish.
 
 ## Who We Serve
 
-### Solo Developer
+### Domain Experts
-The individual shipping side projects, MVPs, or freelance work. Time is their scarcest resource. They context-switch between coding, design, ops, and everything else. They need to move fast without sacrificing quality, and they can't afford to remember every command or best practice.
+Business analysts, operations managers, process owners - people who understand their domain deeply but shouldn't need to code. They want to create and evolve software solutions that support their processes directly, without waiting for IT or hiring developers.
 
-### Small Team (2-5 people)
+### Agencies & Consultancies
-The startup or small product team that needs to punch above their weight. They don't have dedicated specialists for every function. They need consistency across contributors and visibility into what's happening without heavyweight process.
+Teams building solutions for clients using our platform. They need speed, consistency, and the ability to deliver maintainable solutions across engagements. Every efficiency gain multiplies across projects.
 
-### Agency / Consultancy
+### Organizations
-Building for clients under deadlines. They need speed, consistency, and the ability to apply learnings across projects. Every efficiency gain multiplies across engagements.
+From small businesses to enterprises - any organization that needs maintainable software to support their business processes. They benefit from solutions built on our platform, whether created by their own domain experts or by agencies on their behalf.
 
 ## What They're Trying to Achieve
 
-- "Help me ship without getting bogged down in repetitive tasks"
+- "Help me create software that supports my business process without learning to code"
-- "Help me maintain quality without slowing down"
+- "Help me evolve my solutions as my business changes"
-- "Help me know what to work on next without checking multiple tools"
+- "Help me deliver maintainable solutions to clients faster"
-- "Help me apply best practices without memorizing them"
+- "Help me get software that actually fits how we work"
-- "Help me onboard to codebases faster"
+- "Help me reduce dependency on developers for business process changes"
-- "Help me stay in flow instead of context-switching"
 
 ## What We Believe
 
+### Empowering Domain Experts
+
+We believe the people closest to business problems should be able to solve them:
+
+- **Domain expertise matters most.** The person who understands the process deeply is better positioned to design the solution than a developer translating requirements.
+
+- **Low-code removes barriers.** When domain experts can create and evolve solutions directly, organizations move faster and get better-fitting software.
+
+- **Maintainability enables evolution.** Business processes change. Software that supports them must be easy to adapt without starting over.
+
+- **Technology should disappear.** The best tools get out of the way. Domain experts should think about their processes, not about technology.
+
 ### AI-Augmented Development
 
 We believe AI fundamentally changes how software is built:
@@ -55,6 +64,13 @@ We believe AI fundamentally changes how software is built:
 - Automation should free humans for judgment calls
 - The goal is flow, not burnout
 
+### Resource Efficiency
+
+- Software should run well on modest hardware
+- Cloud cost and energy consumption matter
+- ARM64-native where possible - better performance per watt
+- Bloated software is a sign of poor engineering, not rich features
+
 ## Guiding Principles
 
 1. **Encode, don't document.** If something is important enough to write down, it's important enough to encode into a skill, command, or agent that can act on it.
@@ -69,10 +85,10 @@ We believe AI fundamentally changes how software is built:
 
 ## Non-Goals
 
-- **Building for enterprises with complex compliance needs.** We optimize for speed and small teams, not audit trails and approval workflows.
+- **Replacing human judgment.** AI and low-code tools augment human decision-making; they don't replace it. Domain expertise, critical thinking, and understanding of business context remain human responsibilities.
 
 - **Supporting every tool and platform.** We go deep on our chosen stack rather than shallow on everything.
 
-- **Replacing developer judgment.** AI augments human decision-making; it doesn't replace it. Critical thinking, architecture decisions, and user empathy remain human responsibilities.
+- **Building generic software.** We focus on maintainable solutions for business processes, not general-purpose applications.
 
 - **Comprehensive documentation for its own sake.** We encode knowledge into actionable systems. Docs exist to explain the "why," not to duplicate what the system already does.

repos.md

@@ -0,0 +1,71 @@
+# Repository Map
+
+Central registry of all Flowmade repositories.
+
+## How to Use This
+
+Each repo's CLAUDE.md should reference this map for organization context. When working in any repo, Claude can check here to understand how it fits in the bigger picture.
+
+**Status markers:**
+- **Active** - Currently in use
+- **Splitting** - Being broken into smaller repos
+- **Planned** - Will be created (from split or new)
+
+## Repositories
+
+### Organization
+
+| Repo | Purpose | Status | Visibility |
+|------|---------|--------|------------|
+| architecture | Org source of truth: manifesto, Claude tooling, learnings | Active | Public |
+
+### Platform
+
+| Repo | Purpose | Status | Visibility |
+|------|---------|--------|------------|
+| arcadia | Monorepo containing platform code | Splitting | Private |
+| aether | Event sourcing runtime with bytecode VM | Planned (from Arcadia) | Private |
+| iris | WASM UI framework | Planned (from Arcadia) | Public |
+| eskit | ES primitives (aggregates, events, projections, NATS) | Planned (from Arcadia) | Public |
+| adl | Domain language compiler | Planned (from Arcadia) | Private |
+| studio | Visual process designer, EventStorming tools | Planned (from Arcadia) | Private |
+
+### Infrastructure
+
+| Repo | Purpose | Status | Visibility |
+|------|---------|--------|------------|
+| gitserver | K8s-native git server (proves ES/IRIS stack) | Planned | Public |
+
+## Relationships
+
+```
+arcadia (splitting into):
+├── eskit (standalone, foundational)
+├── iris (standalone)
+├── aether (imports eskit)
+├── adl (imports aether)
+└── studio (imports aether, iris, adl)
+
+gitserver (will use):
+├── eskit (event sourcing)
+└── iris (UI)
+```
+
+## Open Source Strategy
+
+See [repo-conventions skill](skills/repo-conventions/SKILL.md) for classification criteria.
+
+**Open source** (public):
+- Generic libraries that benefit from community (eskit, iris)
+- Infrastructure tooling that builds awareness (gitserver)
+- Organization practices and tooling (architecture)
+
+**Proprietary** (private):
+- Core platform IP (aether VM, adl compiler)
+- Product features (studio)
+
+## Related
+
+- [Manifesto](manifesto.md) - Organization identity and beliefs
+- [Issue #53](https://git.flowmade.one/flowmade-one/architecture/issues/53) - Git server proposal
+- [Issue #54](https://git.flowmade.one/flowmade-one/architecture/issues/54) - Arcadia split planning

skills/backlog-grooming/SKILL.md

@@ -1,6 +1,7 @@
 ---
 name: backlog-grooming
 description: Review and improve existing issues for clarity and actionability. Use when grooming the backlog, reviewing issue quality, cleaning up stale issues, or when the user wants to improve existing issues.
+user-invocable: false
 ---
 
 # Backlog Grooming

skills/claude-md-writing/SKILL.md

@@ -0,0 +1,218 @@
+---
+name: claude-md-writing
+description: Write effective CLAUDE.md files that give AI assistants the context they need. Use when creating new repos, improving existing CLAUDE.md files, or setting up projects.
+user-invocable: false
+---
+
+# Writing Effective CLAUDE.md Files
+
+CLAUDE.md is the project's context file for AI assistants. A good CLAUDE.md means Claude understands your project immediately without needing to explore.
+
+## Purpose
+
+CLAUDE.md answers: "What does Claude need to know to work effectively in this repo?"
+
+- **Not a README** - README is for humans discovering the project
+- **Not documentation** - Docs explain how to use the product
+- **Context for AI** - What Claude needs to make good decisions
+
+## Required Sections
+
+### 1. One-Line Description
+
+Start with what this repo is in one sentence.
+
+```markdown
+# Project Name
+
+Brief description of what this project does.
+```
+
+### 2. Organization Context
+
+Link to the bigger picture so Claude understands where this fits.
+
+```markdown
+## Organization Context
+
+This repo is part of Flowmade. See:
+- [Organization manifesto](../architecture/manifesto.md) - who we are, what we believe
+- [Repository map](../architecture/repos.md) - how this fits in the bigger picture
+- [Vision](./vision.md) - what this specific product does
+```
+
+### 3. Setup
+
+How to get the project running locally.
+
+```markdown
+## Setup
+
+\`\`\`bash
+# Clone and install
+git clone <url>
+cd <project>
+make install  # or npm install, etc.
+\`\`\`
+```
+
+### 4. Project Structure
+
+Key directories and what they contain. Focus on what's non-obvious.
+
+```markdown
+## Project Structure
+
+\`\`\`
+project/
+├── cmd/           # Entry points
+├── pkg/           # Shared packages
+│   ├── domain/    # Business logic
+│   └── infra/     # Infrastructure adapters
+├── internal/      # Private packages
+└── api/           # API definitions
+\`\`\`
+```
+
+### 5. Development Commands
+
+The commands Claude will need to build, test, and run.
+
+```markdown
+## Development
+
+\`\`\`bash
+make build    # Build the project
+make test     # Run tests
+make lint     # Run linters
+make run      # Run locally
+\`\`\`
+```
+
+### 6. Architecture Decisions
+
+Key patterns and conventions specific to this repo.
+
+```markdown
+## Architecture
+
+### Patterns Used
+- Event sourcing for state management
+- CQRS for read/write separation
+- Hexagonal architecture
+
+### Conventions
+- All commands go through the command bus
+- Events are immutable value objects
+- Projections rebuild from events
+```
+
+## What Makes a Good CLAUDE.md
+
+### Do Include
+
+- **Enough context to skip exploration** - Claude shouldn't need to grep around
+- **Key architectural patterns** - How the code is organized and why
+- **Non-obvious conventions** - Things that aren't standard
+- **Important dependencies** - External services, APIs, databases
+- **Common tasks** - How to do things Claude will be asked to do
+
+### Don't Include
+
+- **Duplicated manifesto content** - Link to it instead
+- **Duplicated vision content** - Link to vision.md
+- **API documentation** - That belongs elsewhere
+- **User guides** - CLAUDE.md is for the AI, not end users
+- **Obvious things** - Don't explain what `go build` does
+
+## Template
+
+```markdown
+# [Project Name]
+
+[One-line description]
+
+## Organization Context
+
+This repo is part of Flowmade. See:
+- [Organization manifesto](../architecture/manifesto.md) - who we are, what we believe
+- [Repository map](../architecture/repos.md) - how this fits in the bigger picture
+- [Vision](./vision.md) - what this specific product does
+
+## Setup
+
+\`\`\`bash
+# TODO: Add setup instructions
+\`\`\`
+
+## Project Structure
+
+\`\`\`
+project/
+├── ...
+\`\`\`
+
+## Development
+
+\`\`\`bash
+make build    # Build the project
+make test     # Run tests
+make lint     # Run linters
+\`\`\`
+
+## Architecture
+
+### Patterns
+- [List key patterns]
+
+### Conventions
+- [List important conventions]
+
+### Key Components
+- [Describe main components and their responsibilities]
+```
+
+## Examples
+
+### Good: Enough Context
+
+```markdown
+## Architecture
+
+This service uses event sourcing. State is rebuilt from events, not stored directly.
+
+### Key Types
+- `Aggregate` - Domain object that emits events
+- `Event` - Immutable fact that something happened
+- `Projection` - Read model built from events
+
+### Adding a New Aggregate
+1. Create type in `pkg/domain/`
+2. Implement `HandleCommand()` and `ApplyEvent()`
+3. Register in `cmd/main.go`
+```
+
+Claude can now work with aggregates without exploring the codebase.
+
+### Bad: Too Vague
+
+```markdown
+## Architecture
+
+Uses standard Go patterns. See the code for details.
+```
+
+Claude has to explore to understand anything.
+
+## Maintenance
+
+Update CLAUDE.md when:
+- Adding new architectural patterns
+- Changing project structure
+- Adding important dependencies
+- Discovering conventions that aren't documented
+
+Don't update for:
+- Every code change
+- Bug fixes
+- Minor refactors

skills/code-review/SKILL.md

@@ -1,6 +1,7 @@
 ---
 name: code-review
 description: Review code for quality, bugs, security, and style issues. Use when reviewing pull requests, checking code quality, looking for bugs or security vulnerabilities, or when the user asks for a code review.
+user-invocable: false
 ---
 
 # Code Review

skills/gitea/SKILL.md

@@ -1,6 +1,7 @@
 ---
 name: gitea
 description: View, create, and manage Gitea issues and pull requests using tea CLI. Use when working with issues, PRs, viewing issue details, creating pull requests, adding comments, merging PRs, or when the user mentions tea, gitea, issue numbers, or PR numbers.
+user-invocable: false
 ---
 
 # Gitea CLI (tea)

skills/issue-writing/SKILL.md

@@ -1,6 +1,7 @@
 ---
 name: issue-writing
 description: Write clear, actionable issues with proper structure and acceptance criteria. Use when creating issues, writing bug reports, feature requests, or when the user needs help structuring an issue.
+user-invocable: false
 ---
 
 # Issue Writing
@@ -48,6 +49,39 @@ Examples:
 - [ ] Session persists across browser refresh
 ```
 
+## Vertical Slices
+
+Issues should be **vertical slices** that deliver user-visible value.
+
+### The Demo Test
+
+Before writing an issue, ask: **Can a user demo or test this independently?**
+
+- **Yes** → Good issue scope
+- **No** → Rethink the breakdown
+
+### Good vs Bad Issue Titles
+
+| Good (Vertical) | Bad (Horizontal) |
+|-----------------|------------------|
+| "User can save and reload diagram" | "Add persistence layer" |
+| "Show error when login fails" | "Add error handling" |
+| "Domain expert can list orders" | "Add query syntax to ADL" |
+
+### Writing User-Focused Issues
+
+Frame issues around user capabilities:
+
+```markdown
+# Bad: Technical task
+Title: Add email service integration
+
+# Good: User capability
+Title: User receives confirmation email after signup
+```
+
+The technical work is the same, but the good title makes success criteria clear.
+
 ## Issue Types
 
 ### Bug Report

skills/repo-conventions/SKILL.md

@@ -0,0 +1,204 @@
+---
+name: repo-conventions
+description: Standard structure and conventions for Flowmade repositories. Use when creating new repos, reviewing repo structure, or setting up projects.
+user-invocable: false
+---
+
+# Repository Conventions
+
+Standard structure and conventions for Flowmade repositories.
+
+## Repository Layout
+
+All product repos should follow this structure relative to the architecture repo:
+
+```
+org/
+├── architecture/           # Organizational source of truth
+│   ├── manifesto.md        # Organization identity and beliefs
+│   ├── commands/           # Claude Code workflows
+│   ├── skills/             # Knowledge modules
+│   └── agents/             # Subtask handlers
+├── product-a/              # Product repository
+│   ├── vision.md           # Product vision (extends manifesto)
+│   ├── CLAUDE.md           # AI assistant instructions
+│   ├── .gitea/workflows/   # CI/CD pipelines
+│   └── ...
+└── product-b/
+    └── ...
+```
+
+## Required Files
+
+### vision.md
+
+Every product repo needs a vision that extends the organization manifesto.
+
+```markdown
+# Vision
+
+This product vision builds on the [organization manifesto](../architecture/manifesto.md).
+
+## Who This Product Serves
+
+### [Persona Name]
+
+[Product-specific description]
+
+*Extends: [Org persona] (from manifesto)*
+
+## What They're Trying to Achieve
+
+| Product Job | Enables Org Job |
+|-------------|-----------------|
+| "[Product job]" | "[Org job from manifesto]" |
+
+## The Problem
+
+[Pain points this product addresses]
+
+## The Solution
+
+[How this product solves those problems]
+
+## Product Principles
+
+### [Principle Name]
+
+[Description]
+
+*Extends: "[Org principle]"*
+
+## Non-Goals
+
+- **[Non-goal].** [Explanation]
+```
+
+### CLAUDE.md
+
+Project-specific context for AI assistants. See [claude-md-writing skill](../claude-md-writing/SKILL.md) for detailed guidance.
+
+```markdown
+# [Project Name]
+
+[One-line description]
+
+## Organization Context
+
+This repo is part of Flowmade. See:
+- [Organization manifesto](../architecture/manifesto.md) - who we are, what we believe
+- [Repository map](../architecture/repos.md) - how this fits in the bigger picture
+- [Vision](./vision.md) - what this specific product does
+
+## Setup
+
+[How to get the project running locally]
+
+## Project Structure
+
+[Key directories and their purposes]
+
+## Development
+
+[How to build, test, run]
+
+## Architecture
+
+[Key architectural decisions and patterns]
+```
+
+### .gitea/workflows/ci.yaml
+
+Standard CI pipeline. Adapt based on language/framework.
+
+```yaml
+name: CI
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Build
+        run: make build
+      - name: Test
+        run: make test
+      - name: Lint
+        run: make lint
+```
+
+## Naming Conventions
+
+### Repository Names
+
+- Lowercase with hyphens: `product-name`, `service-name`
+- Descriptive but concise
+- No prefixes like `flowmade-` (the org already provides context)
+
+### Branch Names
+
+- `main` - default branch, always deployable
+- `issue-<number>-<short-description>` - feature branches
+- No `develop` or `staging` branches - use main + feature flags
+
+### Commit Messages
+
+- Imperative mood: "Add feature" not "Added feature"
+- First line: summary (50 chars)
+- Body: explain why, not what (the diff shows what)
+- Reference issues: "Fixes #42" or "Closes #42"
+
+## Open vs Proprietary
+
+Decisions about what to open-source are guided by the manifesto:
+
+| Type | Open Source? | Reason |
+|------|--------------|--------|
+| Infrastructure tooling | Yes | Builds community, low competitive risk |
+| Generic libraries | Yes | Ecosystem benefits, adoption |
+| Core platform IP | No | Differentiator, revenue source |
+| Domain-specific features | No | Product value |
+
+When uncertain, default to proprietary. Opening later is easier than closing.
+
+## CI/CD Conventions
+
+### Runners
+
+- Use self-hosted ARM64 runners where possible (resource efficiency)
+- KEDA-scaled runners for burst capacity
+- Cache dependencies aggressively
+
+### Deployments
+
+- Main branch auto-deploys to staging
+- Production requires manual approval or tag
+- Use GitOps (ArgoCD) for Kubernetes deployments
+
+## Dependencies
+
+### Go Projects
+
+- Use Go modules
+- Vendor dependencies for reproducibility
+- Pin major versions, allow minor updates
+
+### General
+
+- Prefer fewer, well-maintained dependencies
+- Audit transitive dependencies
+- Update regularly, don't let them rot
+
+## Documentation
+
+Following the manifesto principle "Encode, don't document":
+
+- CLAUDE.md: How to work with this repo (for AI and humans)
+- vision.md: Why this product exists
+- Code comments: Only for non-obvious "why"
+- No separate docs folder unless user-facing documentation

skills/roadmap-planning/SKILL.md

@@ -1,6 +1,7 @@
 ---
 name: roadmap-planning
 description: Plan features and break down work into implementable issues. Use when planning a feature, creating a roadmap, breaking down large tasks, or when the user needs help organizing work into issues.
+user-invocable: false
 ---
 
 # Roadmap Planning
@@ -32,6 +33,48 @@ How to plan features and create issues for implementation.
 - Reference dependencies explicitly
 - Use consistent labeling
 
+## Vertical vs Horizontal Slices
+
+**Prefer vertical slices** - each issue should deliver user-visible value.
+
+| Vertical (Good) | Horizontal (Bad) |
+|-----------------|------------------|
+| "User can save and reload their diagram" | "Add persistence layer" + "Add save API" + "Add load API" |
+| "Domain expert can list all orders" | "Add query syntax to ADL" + "Add query runtime" + "Add query UI" |
+| "User can reset forgotten password" | "Add email service" + "Add reset token model" + "Add reset form" |
+
+### The Demo Test
+
+Ask: **Can a user demo or test this issue independently?**
+
+- **Yes** → Good vertical slice
+- **No** → Probably a horizontal slice, break differently
+
+### Break by User Capability, Not Technical Layer
+
+Instead of thinking "what technical components do we need?", think "what can the user do after this issue is done?"
+
+```
+# Bad: Technical layers
+├── Add database schema
+├── Add API endpoint
+├── Add frontend form
+
+# Good: User capabilities
+├── User can create a draft
+├── User can publish the draft
+├── User can edit published content
+```
+
+### When Horizontal Slices Are Acceptable
+
+Sometimes horizontal slices are necessary:
+- **Infrastructure setup** - Database, CI/CD, deployment (do once, enables everything)
+- **Security foundations** - Auth system before any protected features
+- **Shared libraries** - When multiple features need the same foundation
+
+Even then, keep them minimal and follow immediately with vertical slices that use them.
+
 ## Breaking Down Features
 
 ### By Layer

skills/vision-management/SKILL.md

@@ -1,123 +1,205 @@
 ---
 name: vision-management
-description: Create, maintain, and evolve a product vision. Use when initializing a vision, updating goals, aligning work with vision, or connecting learnings to vision refinement.
+description: Create, maintain, and evolve organization manifesto and product visions. Use when working with manifesto.md, vision.md, milestones, or aligning work with organizational direction.
+user-invocable: false
 ---
 
 # Vision Management
 
-How to create, maintain, and evolve a product vision for continuous improvement.
+How to create, maintain, and evolve organizational direction at two levels: manifesto (organization) and vision (product).
 
 ## Architecture
 
-The vision system has two layers:
+| Level | Document | Purpose | Command | Location |
+|-------|----------|---------|---------|----------|
+| **Organization** | `manifesto.md` | Identity, shared personas, beliefs, principles | `/manifesto` | `../architecture/` (sibling repo) |
+| **Product** | `vision.md` | Product-specific personas, jobs, solution | `/vision` | Product repo root |
+| **Goals** | Gitea milestones | Measurable progress toward vision | `/vision goals` | Per repo |
 
-| Layer | Purpose | Location |
+Product vision **inherits from and extends** the organization manifesto - it should never duplicate.
-|-------|---------|----------|
-| **vision.md** | North star philosophy (why, principles, non-goals) | File in repo root |
-| **Milestones** | Goals with progress tracking | Gitea milestones |
 
-- **vision.md** is stable - updated rarely when direction changes
+---
-- **Milestones** are actionable - created/closed as goals evolve
-- **Issues** are assigned to milestones to track progress
 
-## Vision Document Structure
+## Manifesto (Organization Level)
 
-The vision.md file should contain the stable "why" and "who" - not progress tracking:
+The manifesto defines who we are as an organization. It lives in the architecture repo and applies across all products.
+
+### Manifesto Structure
+
+```markdown
+# Manifesto
+
+## Who We Are
+Organization identity - what makes us unique.
+
+## Who We Serve
+Shared personas across all products.
+- **Persona Name**: Description, context, constraints
+
+## What They're Trying to Achieve
+Jobs to be done at the organization level.
+- "Help me [outcome] without [pain]"
+
+## What We Believe
+Core beliefs that guide how we work.
+### [Belief Category]
+- Belief point
+- Belief point
+
+## Guiding Principles
+Decision-making rules that apply everywhere.
+1. **Principle**: Explanation
+
+## Non-Goals
+What the organization explicitly does NOT do.
+- **Non-goal**: Why
+```
+
+### When to Update Manifesto
+
+- **Rarely** - this is foundational identity
+- When core beliefs change
+- When adding/removing personas served
+- When adding non-goals based on learnings
+
+### Creating a Manifesto
+
+1. Define organization identity (Who We Are)
+2. Identify shared personas (2-4 max)
+3. Articulate organization-level jobs to be done
+4. Document core beliefs (especially about AI/development)
+5. Establish guiding principles
+6. Define non-goals
+
+---
+
+## Vision (Product Level)
+
+The vision defines what a specific product does. It lives in each product repo and **extends the manifesto**.
+
+### Vision Structure
 
 ```markdown
 # Vision
 
-## Who We Serve (Personas)
+This product vision builds on the [organization manifesto](../architecture/manifesto.md).
-The people we're building for and what characterizes them.
 
-- **Persona Name**: Brief description of who they are, their context, constraints
+## Who This Product Serves
 
-## What They're Trying to Achieve (Jobs to Be Done)
+### [Persona Name]
-The outcomes our personas are trying to accomplish - in their words.
 
-- "Help me [achieve outcome] without [pain point]"
+[Product-specific description]
-- "Help me [do thing] so I can [benefit]"
+
+*Extends: [Org persona] (from manifesto)*
+
+## What They're Trying to Achieve
+
+These trace back to organization-level jobs:
+
+| Product Job | Enables Org Job |
+|-------------|-----------------|
+| "[Product-specific job]" | "[Org job from manifesto]" |
 
 ## The Problem
-Current pain points that prevent our personas from achieving their jobs.
+
+[Pain points this product addresses]
 
 ## The Solution
-How this product addresses the jobs to be done.
 
-## Guiding Principles
+[How this product solves those problems]
-Core beliefs that guide decisions.
+
+## Product Principles
+
+These extend the organization's guiding principles:
+
+### [Principle Name]
+
+[Description]
+
+*Extends: "[Org principle]"*
 
 ## Non-Goals
-What we're explicitly NOT doing (and why).
+
+These extend the organization's non-goals:
+
+- **[Non-goal].** [Explanation]
 ```
 
-Do NOT include goals, progress, or focus in vision.md - that's what milestones are for.
+### When to Update Vision
 
-## Defining Personas
+- When product direction shifts
+- When adding/changing personas served by this product
+- When discovering new non-goals
+- After major learnings from retros
 
-Good personas are:
+### Creating a Product Vision
-- **Specific**: Not "developers" but "solo developers shipping MVPs"
-- **Characterized**: Include constraints, context, priorities
-- **Limited**: 2-4 personas max, or you're building for everyone (no one)
 
-| Bad | Good |
+1. **Start with the manifesto** - read it first
-|-----|------|
+2. Define product personas that extend org personas
-| "Users" | "Solo developer shipping side projects on evenings/weekends" |
+3. Identify product jobs that trace back to org jobs
-| "Developers" | "Small team lead coordinating 2-5 engineers" |
+4. Articulate the problem this product solves
-| "Companies" | "Early-stage startup with no dedicated DevOps" |
+5. Define the solution approach
+6. Set product-specific principles (noting what they extend)
+7. Document product non-goals
+8. Create initial milestones
 
-## Defining Jobs to Be Done
+---
 
-Jobs should be:
+## Inheritance Model
-- **Outcome-focused**: What they want to achieve, not what they do
-- **In their voice**: How they'd describe it, not technical jargon
-- **Pain-aware**: Include what's hard about it today
 
-Format: "Help me [outcome] without [pain]" or "Help me [action] so I can [benefit]"
+```
+Manifesto (org)              Vision (product)
+├── Personas            →    Product Personas (extend with specifics)
+├── Jobs                →    Product Jobs (trace back to org jobs)
+├── Beliefs             →    (inherited, never duplicated)
+├── Principles          →    Product Principles (extend, note source)
+└── Non-Goals           →    Product Non-Goals (additive)
+```
 
-| Bad | Good |
+### Inheritance Rules
-|-----|------|
-| "Git integration" | "Help me commit and push without remembering git commands" |
-| "Issue tracking" | "Help me know what to work on next without checking 5 tools" |
-| "Code review" | "Help me catch bugs before they ship without slowing down" |
 
-## Creating a Vision
+| Component | Rule | Format |
+|-----------|------|--------|
+| **Personas** | Extend with product-specific context | `*Extends: [Org persona] (from manifesto)*` |
+| **Jobs** | Trace back to org-level jobs | Table with Product Job → Org Job columns |
+| **Beliefs** | Inherited automatically | Never include in vision |
+| **Principles** | Add product-specific, note what they extend | `*Extends: "[Org principle]"*` |
+| **Non-Goals** | Additive | Org non-goals apply automatically |
 
-When no vision exists:
+### Example
 
-1. **Define personas**: Who are we building for? (2-4 specific personas)
+**Manifesto** (organization):
-2. **Identify jobs to be done**: What are they trying to achieve?
+```markdown
-3. **Articulate the problem**: What pain points prevent them from achieving their jobs?
+## Who We Serve
-4. **Define the solution**: How does the product address these jobs?
+- **Agencies & Consultancies**: Teams building solutions for clients
-5. **Set guiding principles**: What beliefs guide decisions?
+```
-6. **Document non-goals**: What are you explicitly NOT doing?
-7. **Create initial milestones**: 3-5 measurable goals tied to personas/jobs
 
-### Good Goals (Milestones)
+**Vision** (product - architecture tooling):
+```markdown
+## Who This Product Serves
+
+### Flowmade Developers
+
+The team building Flowmade's platform. They need efficient, consistent AI workflows.
+
+*Extends: Agencies & Consultancies (from manifesto) - we are our own first customer.*
+```
+
+The product persona extends the org persona with product-specific context and explicitly notes the connection.
+
+---
+
+## Milestones (Goals)
+
+Milestones are product-level goals that track progress toward the vision.
+
+### Good Milestones
 
 - Specific and measurable
 - Tied to a persona and job to be done
 - Outcome-focused (not activity-focused)
-- Have clear success criteria in the description
+- Include success criteria in description
 
-| Bad | Good |
-|-----|------|
-| "Improve performance" | "Page load under 2 seconds" |
-| "Better UX" | "User can complete checkout in under 60 seconds" |
-| "More features" | "Support 3 export formats (CSV, JSON, PDF)" |
-
-### Tying Milestones to Personas
-
-Each milestone should clearly serve a persona's job to be done:
-
-```
-Milestone: "Automate routine git workflows"
-For: Solo developer
-Job: "Help me commit and push without remembering git commands"
-Success: /commit, /pr commands handle 80% of git workflows
-```
-
-Include persona context in milestone descriptions:
 ```bash
 tea milestones create --title "Automate routine git workflows" \
   --description "For: Solo developer
@@ -125,35 +207,14 @@ Job: Ship without context switching to git commands
 Success: /commit and /pr commands handle 80% of workflows"
 ```
 
-## Managing Goals with Milestones
+### Milestone-to-Vision Alignment
 
-```bash
+Every milestone should trace to:
-# List milestones with progress
+- A persona (from vision, which extends manifesto)
-tea milestones
+- A job to be done (from vision, which traces to manifesto)
-tea milestones -f title,items_open,items_closed,state
+- A measurable outcome
 
-# Create a new goal
+---
-tea milestones create --title "Automate repetitive workflows" \
-  --description "Success: 80% of routine tasks handled by slash commands"
-
-# View issues in a milestone
-tea milestones issues "Automate repetitive workflows"
-
-# Close a completed goal
-tea milestones close "Automate repetitive workflows"
-```
-
-### Assigning Issues to Milestones
-
-When creating issues, assign them to the relevant milestone:
-
-```bash
-tea issues create --title "Add /commit command" \
-  --description "..." \
-  --milestone "Automate repetitive workflows"
-```
-
-Progress is automatically tracked through open/closed issue counts.
 
 ## Aligning Issues with Vision
 
@@ -161,50 +222,51 @@ When creating or reviewing issues:
 
 1. **Check persona alignment**: Which persona does this serve?
 2. **Check job alignment**: Which job to be done does this enable?
-3. **Check goal alignment**: Does this issue support a milestone?
+3. **Check milestone alignment**: Does this issue support a goal?
 4. **Assign to milestone**: Link the issue to the relevant goal
-5. **Prioritize by focus**: Issues in priority milestones get worked first
-6. **Flag misalignment**: Issues without clear persona/milestone need justification
 
 Every issue should trace back to: "This helps [persona] achieve [job] by [outcome]."
 
 ### Identifying Gaps
 
-Compare vision to current work:
-
 - **Underserved personas**: Which personas have few milestones/issues?
 - **Unaddressed jobs**: Which jobs to be done have no work toward them?
 - **Empty milestones**: Which milestones have no issues?
-- **Stalled milestones**: Which milestones have no recent progress?
+- **Orphan issues**: Issues without a milestone need justification
-- **Orphan issues**: Are there issues without a milestone?
 
-## Connecting Retros to Vision
+---
-
-After a retrospective:
-
-1. **Review learnings**: Any that affect the vision or goals?
-2. **Milestone changes**: Should any goals be added, closed, or modified?
-3. **Non-goal additions**: Did we learn something to add to vision.md?
-4. **Progress check**: Did completed work close any milestones?
-
-### Retro-to-Vision Questions
-
-- "Did this work reveal a new goal we should add as a milestone?"
-- "Did we learn something that should become a non-goal in vision.md?"
-- "Should we close or modify any milestones based on what we learned?"
-- "Are any milestones ready to close?"
 
 ## Continuous Improvement Loop
 
 ```
-Vision → Milestones → Issues → Work → Retro → (Vision/Milestones updated)
+Manifesto → Vision → Milestones → Issues → Work → Retro → (updates)
+                                                    ↓
+                                          Architecture repo issues
+                                                    ↓
+                                          Encoded into learnings +
+                                          skills/commands/agents
 ```
 
-1. **Vision** defines why and principles (stable)
+1. **Manifesto** defines organizational identity (very stable)
-2. **Milestones** define measurable goals
+2. **Vision** defines product direction, extends manifesto (stable)
-3. **Issues** are work items toward those goals
+3. **Milestones** define measurable goals (evolve)
-4. **Work** implements the issues
+4. **Issues** are work items toward goals
-5. **Retros** capture learnings
+5. **Work** implements the issues
-6. **Updates** refine vision and create/close milestones
+6. **Retros** create issues on architecture repo
+7. **Encoding** turns insights into learnings and system improvements
 
-The vision is stable. The milestones evolve as you learn and achieve goals.
+---
+
+## Quick Reference
+
+| Question | Answer |
+|----------|--------|
+| Where do shared personas live? | `manifesto.md` in architecture repo |
+| Where do product personas live? | `vision.md` in product repo (extend org personas) |
+| Where do beliefs live? | `manifesto.md` only (inherited, never duplicated) |
+| Where do goals live? | Gitea milestones (per repo) |
+| What command for org vision? | `/manifesto` |
+| What command for product vision? | `/vision` |
+| What repo for learnings? | Architecture repo |
+| How do product jobs relate to org jobs? | They trace back (show in table) |
+| How do product principles relate? | They extend (note the source) |