Seed Refiner

A Claude Code skill that turns vague project ideas into structured seeds for Attractor pipelines.

The Problem

Attractor pipelines are powerful executors — give them a detailed spec and they'll build working software. But they're literal. If the seed says "process emails," you get shallow email processing. The pipeline can't read your mind about what "process" actually means.

Most people describe what they want casually: "build me an email codifier." They have a rich mental model — to-dos have due dates, reference material needs context, some emails are junk — but none of that makes it into the words they say. The pipeline's expand_spec phase handles technical decisions (language, architecture, testing), but it can't invent domain knowledge that was never provided.

Seed Refiner bridges that gap. Through a short, focused conversation, it draws out the domain knowledge in the user's head and shapes it into a seed the pipeline can act on.

What It Produces

A seed — typically one to two pages of dense domain knowledge, saved to .ai/seed.md. The seed contains:

• Entities — the concepts the system works with and their attributes
• Decisions — what the system decides and how
• Inputs and outputs — what goes in and what comes out
• Scenarios — concrete examples of correct behavior

The seed deliberately excludes all implementation details (language, framework, architecture, file structure, testing strategy). The pipeline figures those out.

Optionally, it can also generate a DOT pipeline file directly from the seed.

How It Works

The skill walks through six phases, asking one question at a time:

1. Understand the Idea — Restate, clarify, identify project type
2. Model the Domain — Entities, attributes, relationships, classifications
3. Define Inputs & Outputs — Data sources, scope, filters, output format
4. Map Decisions — Decision points, rules, edge cases
5. Write Scenarios — Concrete input/output examples for validation
6. Write the Seed — Structured output ready for pipeline consumption

The user doesn't need to be technical. The skill never asks about languages, frameworks, or architecture — only domain knowledge that the pipeline can't figure out on its own.

Installation

Copy the skill into your project's .claude/skills/ directory:

mkdir -p .claude/skills/seed-refiner
cp -r /path/to/seed-refiner/* .claude/skills/seed-refiner/

Or symlink it for use across projects:

ln -s /path/to/seed-refiner ~/.claude/skills/seed-refiner

Usage

In a Claude Code session, mention Attractor, Kilroy, pipelines, or seeds:

> I want to create a seed for an email codifier pipeline
> Help me write a seed for Kilroy — I want to build a tool that...
> Prepare this idea for Attractor: [description]

The skill triggers only when Kilroy, Attractor, pipelines, seeds, or DOT files are explicitly mentioned. It is not a general brainstorming tool.

File Structure

seed-refiner/
├── SKILL.md                        # Main skill definition
└── references/
    ├── domain-modeling.md          # Entity discovery patterns by project type
    ├── seed-template.md            # Output format for the seed
    └── dot-generation.md           # Guidance for generating DOT from seed

Compatibility

Works with any Attractor pipeline implementation:

• Kilroy (Go)
• Forge (Rust)
• Any other implementation of the Attractor spec

The seed output can be fed directly to kilroy attractor ingest or used as input to any tool that consumes Attractor-compatible specifications.

Design Principles

• Only ask what the pipeline can't figure out. Technical decisions are the pipeline's job. Domain knowledge is the user's job. This skill extracts the latter.
• Short and dense. Every sentence in the seed should earn its place. If it's about implementation, it gets cut.
• Domain concepts map to pipeline nodes. The seed is structured so each entity, decision, and processing step becomes a separable unit in the pipeline graph.
• The user doesn't need to be technical. If the skill is asking about frameworks or APIs, it's gone off track.