From boost-dev
Fetch a Shortcut story by URL or ID, explore the current codebase, and generate a high-detail spec-driven implementation plan (.md) ready for the executor.
How this skill is triggered — by the user, by Claude, or both
Slash command
/boost-dev:planThe summary Claude sees in its skill listing — used to decide when to auto-load this skill
Input: **$ARGUMENTS**
Input: $ARGUMENTS
/story/stories-get-by-id with story_public_id: <ID>name, description, story_type, labels, tasks, commentsRead these files:
${CLAUDE_PLUGIN_ROOT}/context/architecture.md${CLAUDE_PLUGIN_ROOT}/context/graphql.md${CLAUDE_PLUGIN_ROOT}/context/testing.md${CLAUDE_PLUGIN_ROOT}/context/database.mdThen explore the actual codebase:
Glob to find existing interactors/services in the same domainGrep to find similar model names, concern usage, or existing mutationsOutput this block before writing anything:
### Analysis
- Domain: [e.g., Automations, Billing, Leads]
- Type: [Feature / Bug / Chore / Refactor]
- Layers affected: [model, interactor, mutation, job, migration, policy, ...]
- Pattern chosen: [e.g., interactor + GraphQL mutation module]
- Why: [1–2 sentences]
- Async?: [yes/no + reason]
- Migration?: [yes/no + summary]
- Diagram needed?: [yes if: async job OR 3+ components in chain OR complex state/decision logic]
- Risks: [anything that could go wrong or needs clarification]
Stop here if there are critical open questions. Otherwise proceed.
Create plan-sc-<ID>-<slug>.md in the current directory.
Quality bar: this plan will be consumed by an automated executor. Every section must be precise enough that no implementation decision is left to guessing. Vague descriptions will produce incorrect code.
# Plan: [Story Title]
**SC:** [SC-ID](URL)
**Branch:** `<git-username>/sc-<ID>/<short-slug>`
**Type:** Feature | Bug | Chore | Refactor
**Domain:** [domain]
**Complexity:** Low | Medium | High
---
## Summary
[2–3 sentences. Synthesize the technical problem — don't copy the story description.]
---
## Technical Decision Record
- **Pattern:** [What and why]
- **GraphQL surface:** [mutation / query / new type fields / none]
- **Async:** [yes/no — reason]
- **Trade-offs / risks:** [be honest]
---
## Flow Diagram
[Include ONLY if: async job OR 3+ components in chain OR complex decision/state logic. Omit entirely otherwise.]
```mermaid
sequenceDiagram
Client->>Mutation: createSomething(args)
Mutation->>SomeInteractor: call(firm, params)
SomeInteractor->>SomeJob: perform_later(id)
SomeInteractor-->>Mutation: result.record
Mutation-->>Client: SomeType
SomeJob->>ExternalAPI: api_call
SomeJob->>Mailer: notify_user
The executor must read these files in full before writing any code.
| File | Why |
|---|---|
app/interactors/<domain>/similar.rb | Reference pattern for this domain |
app/models/some_model.rb | Existing associations and validations |
spec/factories/some_model.rb | Existing factory structure to extend |
spec/support/gql_helpers.rb | Available GraphQL test helpers |
| File | Responsibility |
|---|---|
app/interactors/<domain>/<name>.rb | ... |
app/graphql/types/mutations/<domain>_mutation_type.rb | ... |
spec/interactors/<domain>/<name>_spec.rb | ... |
spec/mutations/<domain>/<name>_spec.rb | ... |
| File | Exact change |
|---|---|
app/graphql/types/mutations/mutation_type.rb | Add include Types::Mutations::NewMutationType |
app/models/some_model.rb | Add has_many :new_records |
[Skip entirely if no migration needed]
# File: db/migrate/TIMESTAMP_description.rb
# Action: create_table / add_column / add_index
# Reversibility: yes
create_table :table_name do |t|
t.references :firm, null: false, foreign_key: true, index: true
t.string :field_name, null: false
t.timestamps
end
Post-migration commands:
bundle exec rails db:migrate RAILS_ENV=test
bundle exec annotaterb annotate_models
Every rule the executor must enforce. Be exhaustive — if it's not here, it won't be implemented.
firm.billing_enabled?]firm.feature?(:notifications), send email after save]Every context.fail! the interactor must have, with the exact error message string.
| Condition | Exact error message |
|---|---|
| [e.g., billing not enabled] | "Billing not enabled for this firm" |
| [e.g., amount <= 0] | "Amount must be greater than 0" |
| [e.g., record save fails] | "Save error: #{record.formatted_errors}" |
What happens after the happy path. If empty, write "None."
InvoiceJob.perform_later(invoice.id) if firm.feature?(:async_invoicing)]InvoiceMailer.created(invoice).deliver_later]invoice.create_activity(:created, owner: current_user)]The executor writes these specs first, verifies they FAIL, then implements until they PASS. Every assertion must use exact values — no
be_presentwhere a value is knowable.
spec/interactors/<domain>/<name>_spec.rbRSpec.describe Domain::DoSomething do
let_it_be(:firm) { SpecContext.firm }
let_it_be(:user) { create(:firm_user, firm:) }
let(:params) { { amount: 100.0, description: 'Test invoice' } }
subject(:result) { described_class.call(firm:, user:, params:) }
it 'creates the record with correct attributes' do
expect(result).to be_success
expect(result.invoice).to be_persisted
expect(result.invoice.amount).to eq(100.0)
expect(result.invoice.firm).to eq(firm)
end
it 'enqueues InvoiceJob after creation' do
expect { result }.to have_enqueued_job(InvoiceJob)
end
context 'when billing is not enabled' do
before { firm.update!(billing_enabled: false) }
it 'fails with exact error' do
expect(result).to be_failure
expect(result.error).to eq('Billing not enabled for this firm')
end
end
context 'when amount is zero' do
let(:params) { { amount: 0 } }
it 'fails with exact error' do
expect(result).to be_failure
expect(result.error).to eq('Amount must be greater than 0')
end
end
end
spec/mutations/<domain>/<name>_spec.rbRSpec.describe 'Mutation: createInvoice' do
let(:variables) { { amount: 100.0 } }
subject(:response) { create_invoice(variables) }
it 'returns the created invoice' do
expect(response.dig('data', 'createInvoice', 'id')).to be_present
expect(response.dig('data', 'createInvoice', 'amount')).to eq(100.0)
end
context 'when billing is not enabled' do
before { SpecContext.firm.update!(billing_enabled: false) }
it 'returns specific error' do
expect(response['errors'].first['message']).to eq('Billing not enabled for this firm')
end
end
end
# spec/factories/<model>.rb
factory :<model> do
firm { SpecContext.firm }
amount { 100.0 }
description { 'Test invoice' }
status { :pending }
trait :paid do
status { :paid }
end
end
Ordered. Each step is atomic. The executor runs specs after each step.
Goal: ... Files: ...
# Full method signatures + business logic skeleton
# Include: guard clauses, context.fail! messages, side effects
def call
validate_firm!
create_invoice
enqueue_job if firm.feature?(:async_invoicing)
end
private
def validate_firm!
context.fail!(error: 'Billing not enabled for this firm') unless firm.billing_enabled?
end
Notes: edge cases, rescue considerations, things the executor must not skip.
[Repeat for each step]
[Only items relevant to this plan]
have_enqueued_job / have_enqueued_mailfirm_id scoped on all new queriesacts_as_paranoid if user-facing entitymutation_type.rbbundle exec rake graphql:dump committed (if GraphQL changed)annotaterb committedsafety_assured avoided or justified[Real blockers only. Omit if none.]
---
## Step 5 — Confirm
After writing the file, output:
- File path saved
- Branch name (ready to copy)
- The 3 most important decisions made
- Whether a diagram was generated and why
- Sections that need human refinement before handing to the executor
npx claudepluginhub kodimtech/claude-plugins --plugin boost-devProvides behavioral guidelines to reduce common LLM coding mistakes, focusing on simplicity, surgical changes, assumption surfacing, and verifiable success criteria.
Searches, retrieves, and installs Agent Skills from prompts.chat registry using MCP tools like search_skills and get_skill. Activates for finding skills, browsing catalogs, or extending Claude.
Creates, edits, and optimizes skills for Claude Code, including drafting, evaluating with test prompts, iterating on performance, and improving skill descriptions for better triggering accuracy.