How long does the integration take?

Change one base URL in an OpenAI-compatible client, or install the Python or TypeScript SDK; the quickstart routes a first request in a few minutes.

Will this lock us into another vendor?

No. The router is Apache-2.0 open source, your provider keys stay yours, and the API is OpenAI-compatible, so leaving is a change of base URL.

What happens when a provider fails?

The router falls back to the next model your policy allows and records the fallback in the trace, so an outage costs a retry, not an incident.

spec - Prompt - OpenSmartRoute

Name: spec
Author: pproenca

Prompt file imported from pproenca/agent-tui (.claude/commands/spec.md). Fill in {{arguments}} before use. Copyright stays with the author.

Spec Command

Transform a brainstorm artifact into a formal, actionable specification with all decisions made.

Artifact Chain

.claude/specs/<feature-name>/
├── brainstorm.md    ← Input (from /brainstorm)
└── spec.md          ← Output (this command)

Downstream: /plan-tdd <feature-name> reads spec.md to create tasks.

Execution Flow

Step 1: Load Brainstorm

Extract feature name from argument: {{arguments}}

Look for brainstorm at: .claude/specs/<feature-name>/brainstorm.md

If not found:

No brainstorm found for '<feature-name>'.

Options:
○ Run `/brainstorm <feature-name>` first (Recommended)
○ Create spec from scratch
○ Point to different brainstorm file

If found, read the entire brainstorm.md file.

Step 2: Resolve Open Questions

Extract all - [ ] items from "Open questions" section.

For each unresolved question, use AskUserQuestion to get a decision:

Open Question: <question from brainstorm>

Context: <relevant context from brainstorm>

○ Option A: <if applicable>
○ Option B: <if applicable>
○ Need more research
○ Out of scope for now

If "Need more research" is selected, optionally use WebSearch or Task(Explore) to gather information, then re-ask.

Step 3: Choose Approach

If multiple approaches were identified in brainstorm:

Which approach should we pursue?

Based on brainstorm, the options are:

○ Approach A: <name>
  <brief description>
  Pros: <key pros>
  Cons: <key cons>

○ Approach B: <name>
  <brief description>
  Pros: <key pros>
  Cons: <key cons>

○ Hybrid: Combine elements
○ Need more analysis

Step 4: Define Scope

Present must-haves and nice-to-haves from brainstorm:

Confirm scope for this specification:

Must-haves (from brainstorm):
☑ <item 1>
☑ <item 2>
☐ <item 3> - move to nice-to-have?

Nice-to-haves:
☐ <item 1> - include in v1?
☐ <item 2>

Add anything missing?

Step 5: Architectural Decisions

Based on chosen approach and codebase context, make architectural decisions:

For each significant decision:

Architectural Decision: <topic>

Context: <why this decision matters>

Options:
○ Option A: <description>
○ Option B: <description>

Recommendation: <which and why>

Capture as ADR (Architecture Decision Record) format.

Step 6: Define Interfaces

Based on the approach, define key interfaces/contracts:

Public API surface
Data structures
Integration points
Error handling strategy

Step 7: Generate Specification

Write to .claude/specs/<feature-name>/spec.md:

# <Feature Name> - Specification

> Generated: <timestamp>
> Status: specified
> Brainstorm: [brainstorm.md](./brainstorm.md)
> Next: `/plan-tdd <feature-name>` to create implementation tasks

## Overview

### Problem Statement
<refined from brainstorm - one clear paragraph>

### Solution Summary
<chosen approach in 2-3 sentences>

### Success Criteria
- [ ] <measurable criterion 1>
- [ ] <measurable criterion 2>
- [ ] <measurable criterion 3>

## Scope

### In Scope (v1)
- <feature 1>
- <feature 2>

### Out of Scope
- <explicitly excluded item 1>
- <explicitly excluded item 2>

### Future Considerations
- <potential v2 feature>

## Architecture

### Chosen Approach
<detailed description of the selected approach>

### Rationale
<why this approach over alternatives>

### Component Overview

Architectural Decisions

ADR-1:

Status: Accepted

Context:

Decision:

Consequences:

<negative consequence / trade-off>

ADR-2:

...

Interfaces

Public API

// Or appropriate language
<key interfaces, traits, function signatures>

Data Structures

<key types, structs, enums>

Error Handling

Integration Points

Dependencies

: <how it's used>
: <how it's used>

Affected Components

Constraints

Technical

Performance Requirements

Risks & Mitigations

Risk	Likelihood	Impact	Mitigation
<risk 1>	<H/M/L>	<H/M/L>

Open Items

Resolved (from brainstorm)

Deferred

Testing Strategy

Unit Tests

Integration Tests

Acceptance Criteria Tests

Rollout Plan

Phase 1

Phase 2

Next Steps

Run /plan-tdd <feature-name> to:

Decompose into implementation tasks
Create TDD task chains
Set up dependencies
Start building!


### Step 8: Summary

Display to user:

Specification Complete

Artifact: .claude/specs/<feature-name>/spec.md

Decisions Made

Approach:
Scope: must-haves, nice-to-haves deferred
ADRs: architectural decisions recorded

Key Interfaces

Risks Identified

risks with mitigations

Next Step

Run /plan-tdd <feature-name> to create implementation tasks.


## Spec Quality Checklist

Before completing, verify:
- [ ] All open questions resolved or explicitly deferred
- [ ] Single approach chosen (no "maybe this or that")
- [ ] Success criteria are measurable
- [ ] Scope is explicit (in/out)
- [ ] Key interfaces defined
- [ ] Risks have mitigations
- [ ] Testing strategy outlined

Install spec and it becomes one more candidate the router can pick - when it fits.

A listing is a routing target with a manifest: what it does, which domains it covers, what it costs and who publishes it. Once installed it sits beside your own models and tools, is scored like any other candidate for each request, and shows up in the trace when it wins. Ratings come from workspaces that installed it, one per account.

# Spec Command Transform a brainstorm artifact into a formal, actionable specification with all decisions made. ## Artifact Chain ``` .claude/specs/<feature-name>/ ├── brainstorm.md ← Input (from /brainstorm) └── spec.md ← Output (this command) ``` Downstream: `/plan-tdd <feature-name>` reads `spec.md` to create tasks. ## Execution Flow ### Step 1: Load Brainstorm Extract feature name from argument: `{{arguments}}` Look for brainstorm at: `.claude/specs/<feature-name>/brainstorm.md` If not found: ``` No brainstorm found for '<feature-name>'. Options: ○ Run `/brainstorm <feature-name>` first (Recommended) ○ Create spec from scratch ○ Point to different brainstorm file ``` If found, read the entire brainstorm.md file. ### Step 2: Resolve Open Questions Extract all `- [ ]` items from "Open questions" section. For each unresolved question, use AskUserQuestion to get a decision: ``` Open Question: <question from brainstorm> Context: <relevant context from brainstorm> ○ Option A: <if applicable> ○ Option B: <if applicable> ○ Need more research ○ Out of scope for now ``` If "Need more research" is selected, optionally use WebSearch or Task(Explore) to gather information, then re-ask. ### Step 3: Choose Approach If multiple approaches were identified in brainstorm: ``` Which approach should we pursue? Based on brainstorm, the options are: ○ Approach A: <name> <brief description> Pros: <key pros> Cons: <key cons> ○ Approach B: <name> <brief description> Pros: <key pros> Cons: <key cons> ○ Hybrid: Combine elements ○ Need more analysis ``` ### Step 4: Define Scope Present must-haves and nice-to-haves from brainstorm: ``` Confirm scope for this specification: Must-haves (from brainstorm): ☑ <item 1> ☑ <item 2> ☐ <item 3> - move to nice-to-have? Nice-to-haves: ☐ <item 1> - include in v1? ☐ <item 2> Add anything missing? ``` ### Step 5: Architectural Decisions Based on chosen approach and codebase context, make architectural decisions: For each significant decision: ``` Architectural Decision: <topic> Context: <why this decision matters> Options: ○ Option A: <description> ○ Option B: <description> Recommendation: <which and why> ``` Capture as ADR (Architecture Decision Record) format. ### Step 6: Define Interfaces Based on the approach, define key interfaces/contracts: - Public API surface - Data structures - Integration points - Error handling strategy ### Step 7: Generate Specification Write to `.claude/specs/<feature-name>/spec.md`: ```markdown # <Feature Name> - Specification > Generated: <timestamp> > Status: specified > Brainstorm: [brainstorm.md](./brainstorm.md) > Next: `/plan-tdd <feature-name>` to create implementation tasks ## Overview ### Problem Statement <refined from brainstorm - one clear paragraph> ### Solution Summary <chosen approach in 2-3 sentences> ### Success Criteria - [ ] <measurable criterion 1> - [ ] <measurable criterion 2> - [ ] <measurable criterion 3> ## Scope ### In Scope (v1) - <feature 1> - <feature 2> ### Out of Scope - <explicitly excluded item 1> - <explicitly excluded item 2> ### Future Considerations - <potential v2 feature> ## Architecture ### Chosen Approach <detailed description of the selected approach> ### Rationale <why this approach over alternatives> ### Component Overview ``` <ASCII diagram or description of components> ``` ## Architectural Decisions ### ADR-1: <Decision Title> **Status:** Accepted **Context:** <why this decision is needed> **Decision:** <what we decided> **Consequences:** - <positive consequence> - <negative consequence / trade-off> ### ADR-2: <Decision Title> ... ## Interfaces ### Public API ```rust // Or appropriate language <key interfaces, traits, function signatures> ``` ### Data Structures ```rust <key types, structs, enums> ``` ### Error Handling <error strategy, error types, recovery behavior> ## Integration Points ### Dependencies - <internal dependency>: <how it's used> - <external dependency>: <how it's used> ### Affected Components - <component>: <what changes> ## Constraints ### Technical <from brainstorm, refined> ### Performance Requirements <specific numbers if applicable> ## Risks & Mitigations | Risk | Likelihood | Impact | Mitigation | |------|------------|--------|------------| | <risk 1> | <H/M/L> | <H/M/L> | <mitigation> | ## Open Items ### Resolved (from brainstorm) - [x] <question> → <answer> - [x] <question> → <answer> ### Deferred - <item deferred to future> ## Testing Strategy ### Unit Tests <what to unit test> ### Integration Tests <what to integration test> ### Acceptance Criteria Tests <how to verify success criteria> ## Rollout Plan ### Phase 1 <initial rollout scope> ### Phase 2 <expanded scope if applicable> --- ## Next Steps Run `/plan-tdd <feature-name>` to: 1. Decompose into implementation tasks 2. Create TDD task chains 3. Set up dependencies 4. Start building! ``` ### Step 8: Summary Display to user: ``` ## Specification Complete Artifact: `.claude/specs/<feature-name>/spec.md` ### Decisions Made - Approach: <chosen approach> - Scope: <X> must-haves, <Y> nice-to-haves deferred - ADRs: <count> architectural decisions recorded ### Key Interfaces <list main interfaces defined> ### Risks Identified <count> risks with mitigations ### Next Step Run `/plan-tdd <feature-name>` to create implementation tasks. ``` ## Spec Quality Checklist Before completing, verify: - [ ] All open questions resolved or explicitly deferred - [ ] Single approach chosen (no "maybe this or that") - [ ] Success criteria are measurable - [ ] Scope is explicit (in/out) - [ ] Key interfaces defined - [ ] Risks have mitigations - [ ] Testing strategy outlined

{ "prompt": "# Spec Command\n\nTransform a brainstorm artifact into a formal, actionable specification with all decisions made.\n\n## Artifact Chain\n\n```\n.claude/specs/<feature-name>/\n├── brainstorm.md ← Input (from /brainstorm)\n└── spec.md ← Output (this command)\n```\n\nDownstream: `/plan-tdd <feature-name>` reads `spec.md` to create tasks.\n\n## Execution Flow\n\n### Step 1: Load Brainstorm\n\nExtract feature name from argument: `{{arguments}}`\n\nLook for brainstorm at: `.claude/specs/<feature-name>/brainstorm.md`\n\nIf not found:\n```\nNo brainstorm found for '<feature-name>'.\n\nOptions:\n○ Run `/brainstorm <feature-name>` first (Recommended)\n○ Create spec from scratch\n○ Point to different brainstorm file\n```\n\nIf found, read the entire brainstorm.md file.\n\n### Step 2: Resolve Open Questions\n\nExtract all `- [ ]` items from \"Open questions\" section.\n\nFor each unresolved question, use AskUserQuestion to get a decision:\n```\nOpen Question: <question from brainstorm>\n\nContext: <relevant context from brainstorm>\n\n○ Option A: <if applicable>\n○ Option B: <if applicable>\n○ Need more research\n○ Out of scope for now\n```\n\nIf \"Need more research\" is selected, optionally use WebSearch or Task(Explore) to gather information, then re-ask.\n\n### Step 3: Choose Approach\n\nIf multiple approaches were identified in brainstorm:\n\n```\nWhich approach should we pursue?\n\nBased on brainstorm, the options are:\n\n○ Approach A: <name>\n <brief description>\n Pros: <key pros>\n Cons: <key cons>\n\n○ Approach B: <name>\n <brief description>\n Pros: <key pros>\n Cons: <key cons>\n\n○ Hybrid: Combine elements\n○ Need more analysis\n```\n\n### Step 4: Define Scope\n\nPresent must-haves and nice-to-haves from brainstorm:\n\n```\nConfirm scope for this specification:\n\nMust-haves (from brainstorm):\n☑ <item 1>\n☑ <item 2>\n☐ <item 3> - move to nice-to-have?\n\nNice-to-haves:\n☐ <item 1> - include in v1?\n☐ <item 2>\n\nAdd anything missing?\n```\n\n### Step 5: Architectural Decisions\n\nBased on chosen approach and codebase context, make architectural decisions:\n\nFor each significant decision:\n```\nArchitectural Decision: <topic>\n\nContext: <why this decision matters>\n\nOptions:\n○ Option A: <description>\n○ Option B: <description>\n\nRecommendation: <which and why>\n```\n\nCapture as ADR (Architecture Decision Record) format.\n\n### Step 6: Define Interfaces\n\nBased on the approach, define key interfaces/contracts:\n\n- Public API surface\n- Data structures\n- Integration points\n- Error handling strategy\n\n### Step 7: Generate Specification\n\nWrite to `.claude/specs/<feature-name>/spec.md`:\n\n```markdown\n# <Feature Name> - Specification\n\n> Generated: <timestamp>\n> Status: specified\n> Brainstorm: [brainstorm.md](./brainstorm.md)\n> Next: `/plan-tdd <feature-name>` to create implementation tasks\n\n## Overview\n\n### Problem Statement\n<refined from brainstorm - one clear paragraph>\n\n### Solution Summary\n<chosen approach in 2-3 sentences>\n\n### Success Criteria\n- [ ] <measurable criterion 1>\n- [ ] <measurable criterion 2>\n- [ ] <measurable criterion 3>\n\n## Scope\n\n### In Scope (v1)\n- <feature 1>\n- <feature 2>\n\n### Out of Scope\n- <explicitly excluded item 1>\n- <explicitly excluded item 2>\n\n### Future Considerations\n- <potential v2 feature>\n\n## Architecture\n\n### Chosen Approach\n<detailed description of the selected approach>\n\n### Rationale\n<why this approach over alternatives>\n\n### Component Overview\n```\n<ASCII diagram or description of components>\n```\n\n## Architectural Decisions\n\n### ADR-1: <Decision Title>\n\n**Status:** Accepted\n\n**Context:** <why this decision is needed>\n\n**Decision:** <what we decided>\n\n**Consequences:**\n- <positive consequence>\n- <negative consequence / trade-off>\n\n### ADR-2: <Decision Title>\n...\n\n## Interfaces\n\n### Public API\n\n```rust\n// Or appropriate language\n<key interfaces, traits, function signatures>\n```\n\n### Data Structures\n\n```rust\n<key types, structs, enums>\n```\n\n### Error Handling\n\n<error strategy, error types, recovery behavior>\n\n## Integration Points\n\n### Dependencies\n- <internal dependency>: <how it's used>\n- <external dependency>: <how it's used>\n\n### Affected Components\n- <component>: <what changes>\n\n## Constraints\n\n### Technical\n<from brainstorm, refined>\n\n### Performance Requirements\n<specific numbers if applicable>\n\n## Risks & Mitigations\n\n| Risk | Likelihood | Impact | Mitigation |\n|------|------------|--------|------------|\n| <risk 1> | <H/M/L> | <H/M/L> | <mitigation> |\n\n## Open Items\n\n### Resolved (from brainstorm)\n- [x] <question> → <answer>\n- [x] <question> → <answer>\n\n### Deferred\n- <item deferred to future>\n\n## Testing Strategy\n\n### Unit Tests\n<what to unit test>\n\n### Integration Tests\n<what to integration test>\n\n### Acceptance Criteria Tests\n<how to verify success criteria>\n\n## Rollout Plan\n\n### Phase 1\n<initial rollout scope>\n\n### Phase 2\n<expanded scope if applicable>\n\n---\n\n## Next Steps\n\nRun `/plan-tdd <feature-name>` to:\n1. Decompose into implementation tasks\n2. Create TDD task chains\n3. Set up dependencies\n4. Start building!\n```\n\n### Step 8: Summary\n\nDisplay to user:\n```\n## Specification Complete\n\nArtifact: `.claude/specs/<feature-name>/spec.md`\n\n### Decisions Made\n- Approach: <chosen approach>\n- Scope: <X> must-haves, <Y> nice-to-haves deferred\n- ADRs: <count> architectural decisions recorded\n\n### Key Interfaces\n<list main interfaces defined>\n\n### Risks Identified\n<count> risks with mitigations\n\n### Next Step\nRun `/plan-tdd <feature-name>` to create implementation tasks.\n```\n\n## Spec Quality Checklist\n\nBefore completing, verify:\n- [ ] All open questions resolved or explicitly deferred\n- [ ] Single approach chosen (no \"maybe this or that\")\n- [ ] Success criteria are measurable\n- [ ] Scope is explicit (in/out)\n- [ ] Key interfaces defined\n- [ ] Risks have mitigations\n- [ ] Testing strategy outlined", "variables": [ "arguments" ], "notes": "Transform brainstorm into formal specification with decisions made Tools: Read, Write, Glob, Grep, AskUserQuestion, Task, WebSearch. Arguments: <feature-name>.", "metadata": { "source": { "provider": "github-claude-commands", "repository": "https://github.com/pproenca/agent-tui", "path": ".claude/commands/spec.md", "ref": "8bf76c4664e431e9e73d9be089b703020d48f996", "url": "https://github.com/pproenca/agent-tui/blob/8bf76c4664e431e9e73d9be089b703020d48f996/.claude/commands/spec.md", "key": "pproenca/agent-tui/.claude/commands/spec.md" } } }