How to use the AI-enabled SDLC

Take work from an idea to a draft pull request with the EOS skills. Each project stage produces one artefact that the next stage reads. Human review and merge follow the draft pull request.

This guide assumes you can run EOS skills in your agent. For plugin install, see How to consume the EOS plugin marketplace. For Notion, Atlassian, and GitHub CLI access, see How to connect SDLC integrations.

Do not write the ticket, PRD, or plan in the prompt. Give the skill a ticket key, a Notion link, or a screenshot. The skill asks for the rest.

Before you start

1. Install eos@eos, engineering@eos, and product@eos globally with APM.
2. Connect the integration that the next stage requires.
3. Update global plugins before you start a new piece of work:
   sh

   apm update --global
   

Scout is optional. When scout is on PATH, SDLC skills load team and repository context from it. See How to use Scout.

Check your setup

Run /ask-eos if this is your first time, or if a skill stops because a tool is missing.

Neither flow installs, uninstalls, or reconnects anything unless you agree.

If a personal skill such as create-prd sits in ~/.claude/skills, the readiness check can report a clash with the EOS skill. Use the EOS skill.

Choose the workflow

Use /start-work when you are not sure which skill to run. It routes to one downstream skill. It does not create artefacts itself.

/start-work checkout failed for a gift card order

/start-work we want a new Buyer Hub reporting project

flowchart TD
    Start["Start work request"] --> Project{"Project or initiative?"}
    Project -->|Yes, details unsettled| CreateSpike["/create-spike-ticket"]
    Project -->|Yes, details settled| CreateProject["/create-project"]
    Project -->|No| Bug{"Existing defect?"}
    Bug -->|Yes| CreateBug["/create-bug-ticket"]
    Bug -->|No| Enhancement{"One bounded improvement?"}
    Enhancement -->|Yes, details unsettled| CreateSpike
    Enhancement -->|Yes, details settled| CreateEnhancement["/create-enhancement-ticket"]
    Enhancement -->|No| RefinedTicket{"Refined ticket already exists?"}
    RefinedTicket -->|Yes| Implement["/implement"]
    RefinedTicket -->|No| Questions["Ask for more context"]

If /start-work cannot classify the request, it asks follow-up questions and routes again.

Create a standalone ticket

Not every change needs a PRD, TSD, or implementation plan.

Enhancement

Use /create-enhancement-ticket for one bounded improvement to an existing product or service. The skill drafts a small implementation plan, checks for duplicates when you ask, and creates the Jira issue. It does not need a Notion project or an epic.

/create-enhancement-ticket add a CSV export on the settlement report

If unanswered questions still block a safe ticket, the skill routes to /create-spike-ticket instead of a weak Enhancement.

Bug

Use /create-bug-ticket to create an implementation-ready Jira Bug. Give it the observed behaviour, a screenshot, or a trace link. It is not a bug-report inbox. It captures enough technical detail for a human or agent to fix the defect.

/create-bug-ticket checkout charged the card twice

Spike

Use /create-spike-ticket when the destination is known but a blocking unknown remains. A spike records decisions. Do not implement a spike with /implement.

/create-spike-ticket we want to speed up order processing during peak hours

After the decisions exist, use /resolve-spike-ticket and return to the originating workflow. See How to create a spike ticket and How to resolve a spike ticket.

Run a project through six stages

Use this path for a new capability, several deliverables, or work that needs product discovery before implementation. Stages 0 and 1 use product@eos. Stages 2 to 5 use engineering@eos.

flowchart TD
    S0["Stage 0 · /create-project"] --> A0["Notion project page"]
    A0 --> S1["Stage 1 · /create-prd"]
    S1 --> A1["PRD"]
    A1 --> S2["Stage 2 · /create-tsd"]
    S2 --> A2["TSD"]
    A2 --> S3["Stage 3 · /create-implementation-plan"]
    S3 --> A3["Implementation plan"]
    A3 --> S4["Stage 4 · /create-tickets"]
    S4 --> A4["Jira epic and issues"]
    A4 --> S5["Stage 5 · /implement"]
    S5 --> A5["Draft pull request"]

Start at the earliest incomplete stage. Do not skip a missing artefact. Do not treat a draft PRD or TSD as approved.

Skill descriptions and templates are in the EOS marketplace skills reference.

Stage 0: Create the project page

/create-project Preview ChoicePlus themes. Team Cards and Payments

The skill searches Ideas/Initiatives for a similar project and asks you to confirm it is not a duplicate. It then collects Name, Team, and SDL. Later stages locate context from this page. Do not skip it.

You can point the skill at an existing Notion page. It can move that page under the project, or copy pasted or local content into a new subpage.

Stage 1: Write the PRD

/create-prd <project page link>

Confirm the scope class before the skill drafts: new product, single-system feature, multi-system feature, or small change. The skill scales optional sections to that class.

Every PRD includes these core sections:

1. Problem statement
2. Goals and success metrics
3. Solution overview
4. Functional requirements
5. Out of scope
6. Effort and feasibility

You supply the product judgement. The skill structures it. Approve the PRD before you start the TSD.

Stage 2: Write the TSD

The TSD is a Notion subpage titled TSD — Feature name.

• Use /create-tsd when the context supports every required section. The skill writes the complete document. It must not invent missing decisions.
• Use /create-tsd-guided when a required section still needs context. The skill creates an empty scaffold, then fills one section at a time.
• Use /create-tsd-section to write or revise one heading on an existing TSD.

/create-tsd <project page link>

/create-tsd-section Architecture <TSD link>

Required sections:

Optional sections, included only when relevant:

You own architecture, trade-offs, and technical approval. Do not advance while material sections or decisions remain unresolved. Route a blocking unknown to /create-spike-ticket.

Stage 3: Write the implementation plan

/create-implementation-plan <project page link>

The skill stops if the PRD or TSD is missing. It reads both documents, checks the repository against the TSD, and shows the milestone and task tree before it writes the Notion page.

Use foundational milestones only where shared work unblocks later tasks. Slice the rest into vertical, independently demoable outcomes. Do not slice by frontend, backend, and database layers.

Approve task boundaries before the skill writes. Oversized slices risk context loss in ticket creation. Tiny slices create coordination overhead.

Stage 4: Create tickets for one milestone

/create-tickets <implementation plan link>

Create tickets for one milestone at a time, not the whole project. The skill explores each resolved repository, then drafts one ticket per repository outcome. Cross-repository plan tasks become separate tickets.

Each ticket includes context, implementation criteria, files when known, testing, acceptance criteria, and related links. Treat the ticket as the prompt that a developer or agent will pick up.

The skill shows a full dry run. Confirm it before any Jira write. After a successful publish, it writes issue keys back onto the Notion plan.

Stage 5: Implement the ticket

/implement AI-123

Start from a branch named {ticketId}-{title}, for example AI-123-add-csv-export. The skill can check out that branch from the ticket key.

The skill fetches the ticket and parent context, stops on vague requirements, confirms an approach, builds test-first with /tdd, commits with /conventional-commit, runs repository verification, and opens a draft pull request with /raise-pr.

Do not use /implement on a spike. Resolve the spike first, then return to the planning workflow.

Confirm the result

You are done with a standalone ticket when Jira contains a Bug or Enhancement that is ready to implement and that you reviewed.

You are done with a project stage when the named artefact exists, you have approved it, and the next stage can read it.

You are done with implementation when GitHub has a draft pull request for the ticket branch. Human review and merge still follow.

If a skill stops because Notion, Atlassian, or gh is missing, return to How to connect SDLC integrations.