Skip to content
Back to search

the-startup

MarketplaceWorks with Claude CodeGitHubIncomplete

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/rsmdt-the-startup/badge.svg)](/listings/rsmdt-the-startup)

HTML

<a href="/listings/rsmdt-the-startup"><img src="/api/listings/rsmdt-the-startup/badge.svg" alt="findsafeskills safety rating" /></a>

Install

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

These steps run a script from the network that findsafeskills does not scan.

**Requirements:** Claude Code v2.0+ with marketplace support

curl -fsSL https://raw.githubusercontent.com/rsmdt/the-startup/main/install.sh | sh

This installs the core plugins, configures the default output style, and sets up the [statusline](#-statusline) with a customizable config file.

<details> <summary><strong>Manual Installation</strong></summary>

Start `claude` and run the following:

# Add The Agentic Startup marketplace
/plugin marketplace add rsmdt/the-startup

/plugin install start@the-startup  # Install the Start plugin (core workflows)
/plugin install team@the-startup   # (Optional) Install the Team plugin (specialized agents)

</details>

**After installation:**

# (Optional) Create project governance rules
/constitution                      # Auto-enforced during specify, implement, review

# Switch output styles anytime
/output-style "start:The Startup"   # High-energy, fast execution (default)
/output-style "start:The ScaleUp"   # Calm confidence, educational

---

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

.claude-plugin/marketplace.json · Manifest · 23 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. {
  2. "name": "the-startup",
  3. "owner": {
  4. "name": "Rudolf S."
  5. },
  6. "metadata": {
  7. "description": "Comprehensive agentic framework for Claude Code",
  8. "version": "4.0.0",
  9. "homepage": "https://github.com/rsmdt/the-startup"
  10. },
  11. "plugins": [
  12. {
  13. "name": "start",
  14. "source": "./plugins/start",
  15. "description": "Core workflow commands with output styles and productivity hooks"
  16. },
  17. {
  18. "name": "team",
  19. "source": "./plugins/team",
  20. "description": "Team consisting of specialized agents for software development"
  21. }
  22. ]
  23. }
README.md · README · 645 lines · 1 finding marked

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. <p align="center">
  2. <img src="https://github.com/rsmdt/the-startup/blob/main/logo.png" width="400" alt="The Agentic Startup">
  3. </p>
  4. <p align="center">
  5. Ship faster. Ship better. Ship with <b>The Agentic Startup</b>.
  6. </p>
  7. <p align="center">
  8. <a href="https://github.com/rsmdt/the-startup/releases/latest">
  9. <img alt="Release" src="https://github.com/rsmdt/the-startup/actions/workflows/release.yml/badge.svg" />
  10. </a>
  11. <a href="https://github.com/rsmdt/the-startup/releases">
  12. <img alt="Downloads" src="https://img.shields.io/github/downloads/rsmdt/the-startup/total?style=flat&label=downloads&color=blue" />
  13. </a>
  14. <a href="https://github.com/rsmdt/the-startup/stargazers">
  15. <img alt="GitHub Stars" src="https://img.shields.io/github/stars/rsmdt/the-startup?style=flat&color=yellow" />
  16. </a>
  17. <a href="https://github.com/hesreallyhim/awesome-claude-code">
  18. <img alt="Mentioned in Awesome Claude Code" src="https://awesome.re/mentioned-badge.svg" />
  19. </a>
  20. </p>
  21. ---
  22. ## Table of Contents
  23. - [🤖 What is The Agentic Startup?](#-what-is-the-agentic-startup)
  24. - [🚀 Quick Start](#-quick-start)
  25. - [📖 The Complete Workflow](#-the-complete-workflow)
  26. - [🎯 Which Skill Should I Use?](#-which-skill-should-i-use)
  27. - [📦 Plugins](#-plugins)
  28. - [🎨 Output Styles](#-output-styles)
  29. - [📊 Statusline](#-statusline)
  30. - [💡 Why The Agentic Startup?](#-why-the-agentic-startup)
  31. - [🎯 Philosophy](#-philosophy)
  32. - [📚 Documentation](#-documentation)
  33. ---
  34. > **New in v3:** Agent Teams (experimental) — enable multi-agent collaboration where specialized agents coordinate and work together on complex tasks. The installer now offers to configure this automatically.
  35. ---
  36. ## 🤖 What is The Agentic Startup?
  37. **The Agentic Startup** is a multi-agent AI framework that makes Claude Code work like a startup team. Create comprehensive specifications before coding, then execute with parallel specialist agents — expert developers, architects, and engineers working together to turn your ideas into shipped code.
  38. **10 slash commands across 3 phases.** Specify first, then build with confidence.
  39. **Key Features:**
  40. - **Spec-Driven Development** — PRD → SDD → task plan → Code
  41. - **One Implementation Loop** — `/implement` runs the plan's tasks through a barriered code→eval retry loop on Claude Code's dynamic-workflow runtime
  42. - **Parallel Agent Execution** — Multiple specialists work simultaneously
  43. - **Quality Gates** — Built-in validation at every stage
  44. - **Zero Configuration** — Marketplace plugins, one-line install
  45. ### Installation
  46. **Requirements:** Claude Code v2.0+ with marketplace support
  47. ```bash
  48. curl -fsSL https://raw.githubusercontent.com/rsmdt/the-startup/main/install.sh | sh
    • Note: Pipes a downloaded script directly into a shell (curl | sh / wget | bash)
    • Line 66 on GitHub
  49. ```
  50. This installs the core plugins, configures the default output style, and sets up the [statusline](#-statusline) with a customizable config file.
  51. <details>
  52. <summary><strong>Manual Installation</strong></summary>
  53. Start `claude` and run the following:
  54. ```bash
  55. # Add The Agentic Startup marketplace
  56. /plugin marketplace add rsmdt/the-startup
  57. /plugin install start@the-startup # Install the Start plugin (core workflows)
  58. /plugin install team@the-startup # (Optional) Install the Team plugin (specialized agents)
  59. ```
  60. </details>
  61. **After installation:**
  62. ```bash
  63. # (Optional) Create project governance rules
  64. /constitution # Auto-enforced during specify, implement, review
  65. # Switch output styles anytime
  66. /output-style "start:The Startup" # High-energy, fast execution (default)
  67. /output-style "start:The ScaleUp" # Calm confidence, educational
  68. ```
  69. ---
  70. ## 🚀 Quick Start
  71. Create a specification and implement it:
  72. ```bash
  73. # Create a specification
  74. /specify Add user authentication with OAuth support
  75. # Execute the implementation
  76. /implement 001
  77. ```
  78. That's it! You're now using spec-driven development.
  79. ---
  80. ## 📖 The Complete Workflow
  81. The Agentic Startup follows **spec-driven development**: comprehensive specifications before code, ensuring clarity and reducing rework.
  82. ### All Skills at a Glance
  83. ```
  84. ┌──────────────────────────────────────────────────────────┐
  85. │ SETUP (optional) │
  86. │ │
  87. │ /constitution ► Create project governance rules │
  88. │ (auto-enforced in BUILD workflow) │
  89. └──────────────────────────────────────────────────────────┘
  90. │
  91. ▼
  92. ┌──────────────────────────────────────────────────────────┐
  93. │ BUILD (primary flow) │
  94. │ │
  95. │ /specify ────► Create specs (Requirements + Solution + Plan) │
  96. │ │ ↳ Plan = ordered task sequence │
  97. │ │ ↳ Constitution checked on SDD │
  98. │ ▼ │
  99. │ /validate ───► Check quality (3 Cs framework) │
  100. │ │ ↳ Constitution mode available │
  101. │ ▼ │
  102. │ /implement ──► Run the task loop (dynamic-workflow) │
  103. │ │ ↳ barriered code→eval retry per task │
  104. │ │ ↳ Constitution enforced │
  105. │ ▼ │
  106. │ /test ───────► Run tests, enforce ownership │
  107. │ │ ↳ No "pre-existing" excuses │
  108. │ ▼ │
  109. │ /review ─────► Multi-agent code review │
  110. │ │ ↳ Constitution compliance checked │
  111. │ ▼ │
  112. │ /document ───► Generate/sync documentation │
  113. └──────────────────────────────────────────────────────────┘
  114. │
  115. ▼
  116. ┌──────────────────────────────────────────────────────────┐
  117. │ MAINTAIN (as needed) │
  118. │ │
  119. │ /analyze ────► Discover patterns & rules │
  120. │ │
  121. │ /refactor ───► Improve code (preserve behavior) │
  122. │ │
  123. │ /debug ──────► Fix bugs (root cause analysis) │
  124. └──────────────────────────────────────────────────────────┘
  125. ```
  126. ### Step-by-Step Walkthrough
  127. #### Step 1: Create Your Specification
  128. ```bash
  129. /specify Add real-time notification system with WebSocket support
  130. ```
  131. This creates a specification directory with one document in three parts plus its holdout scenarios:
  132. ```
  133. .start/specs/001-notification-system/
  134. ├── spec.md # Requirements (what and why), Solution (how), Plan (phases + outcomes), Ledger
  135. ├── review.md # Solution review report
  136. └── .tracker/ # The implementation tasks /implement runs
  137. ├── <phase + slice tasks> # phase = one evaluated outcome; slice = one deliverable, code brief in its body
  138. └── <scenario tasks> # holdout acceptance evidence, per slice
  139. ```
  140. **The spec cycle may take 15-30 minutes.** Claude will research your codebase, ask clarifying questions, and produce comprehensive documents. The process naturally involves multiple back-and-forth exchanges.
  141. #### The plan: a narrative + tracker tasks
  142. The Plan part of `spec.md` is the high-level approach — phases and their achievable outcomes, plus a link to the tracker. The operational units are **tasks** in the spec's tracker (`.start/specs/NNN/.tracker/`, via `task.js`): one **phase** task per plan phase and, under it, one **slice** task per vertical deliverable, whose body correlates:
  143. | Facet | Source | Role |
  144. |-------|--------|------|
  145. | **Features** (acceptance criteria) | Requirements part | what the slice delivers |
  146. | **Behavior** (EARS statements) | Solution part | how it must behave, precisely |
  147. | **Quality Gates** | derived | checkable conditions |
  148. Its acceptance scenarios are separate **scenario child tasks** (holdout evidence — the eval agent reads them, the code agent never does). Slices declare dependencies (`--depends-on`) — that graph is the whole parallelization contract. There is no tier or strategy to choose: a 1-slice plan is a short loop, a 40-slice plan fans out. You always invoke `/specify` and `/implement`; the spec sub-skills (`specify-requirements`, `specify-solution`, `specify-plan`, `specify-meta`) are dispatched internally.
  149. #### Step 2: Handle Context Limits (Resume Pattern)
  150. Large specifications may approach Claude's context window limits. When this happens:
  151. ```bash
  152. # Start a new conversation and resume where you left off
  153. /specify 001
  154. ```
  155. **The resume pattern:**
  156. - Pass the spec ID (e.g., `001`) instead of a description
  157. - Claude reads the existing spec files and continues from there
  158. - You can reset context as many times as needed
  159. - Each document (PRD → SDD → PLAN) can be completed in separate sessions if needed
  160. **Pro tip:** If Claude suggests "you may want to reset context", do it! The quality of output improves with fresh context.
  161. #### Step 3: Validate Before Implementation
  162. ```bash
  163. /validate 001
  164. ```
  165. This quality gate checks:
  166. - **Completeness** - All sections filled, no missing details
  167. - **Consistency** - No contradictions between documents
  168. - **Correctness** - Requirements are testable and achievable
  169. Validation is advisory—it provides recommendations but doesn't block you.
  170. #### Step 4: Execute the Implementation
  171. ```bash
  172. /implement 001
  173. ```
  174. Claude will:
  175. 1. Read the spec's slice tasks from the tracker and topologically sort them by their `--depends-on` edges
  176. 2. Author and run one dynamic workflow — each slice driven through a barriered code→eval loop (a code agent builds it reading the slice task, blind to its scenarios; an eval agent proves it against the slice's scenario child tasks, blind to the slice and the source; failures retry until the satisfaction threshold)
  177. 3. Run independent slices concurrently and dependent ones in order
  178. **Large implementations may also need context resets.** Simply run `/implement 001` again in a fresh conversation—Claude tracks progress in the tracker.
  179. #### Step 5: Review and Ship
  180. ```bash
  181. /review
  182. ```
  183. Four parallel specialists review your code:
  184. - 🔒 **Security** - Authentication, authorization, input validation
  185. - ⚡ **Performance** - Query optimization, memory management
  186. - ✨ **Quality** - Code style, design patterns, maintainability
  187. - 🧪 **Tests** - Coverage gaps, edge cases
  188. ---
  189. ## 🎯 Which Skill Should I Use?
  190. ### Decision Tree
  191. ```
  192. What do you need to do?
  193. │
  194. ├─ Want project-wide guardrails? ─────────► /constitution
  195. │
  196. ├─ Build something new? ──────────────────► /specify
  197. │ Then: /validate → /implement
  198. │
  199. ├─ Understand existing code? ─────────────► /analyze
  200. │ └─ Want to improve it? ───────────────► Then: /refactor
  201. │
  202. ├─ Something is broken? ──────────────────► /debug
  203. │
  204. ├─ Need to run tests? ───────────────────► /test
  205. │
  206. ├─ Code ready for merge? ─────────────────► /review
  207. │
  208. ├─ Need documentation? ───────────────────► /document
  209. │
  210. └─ Check constitution compliance? ────────► /validate constitution
  211. ```
  212. ### Skill Reference
  213. | Skill | Purpose | When to Use |
  214. |---------|---------|-------------|
  215. | `/constitution` | Create governance rules | Establish project-wide guardrails |
  216. | `/specify` | Create specifications (requirements + solution + task plan) | New features, fixes, refactors — any work that benefits from a written spec |
  217. | `/implement` | Run the plan's tasks through the code→eval loop on the dynamic-workflow runtime | After spec is validated |
  218. | `/validate` | Check quality | Before implementation, after specs |
  219. | `/test` | Run tests, enforce ownership | After implementation, fixing bugs |
  220. | `/review` | Multi-agent code review | Before merging PRs |
  221. | `/document` | Generate documentation | After implementation |
  222. | `/analyze` | Extract knowledge | Understanding existing code |
  223. | `/refactor` | Improve code quality | Cleanup without behavior change |
  224. | `/debug` | Fix bugs | When something is broken |
  225. ### Capability Matrix
  226. | Capability | constitution | specify | implement | validate | test | review | document | analyze | refactor | debug |
  227. |------------|:------------:|:-------:|:---------:|:--------:|:----:|:------:|:--------:|:-------:|:--------:|:-----:|
  228. | **Creates specifications** | - | ✅ | - | - | - | - | - | - | - | - |
  229. | **Executes implementation plans** | - | - | ✅ | - | - | - | - | - | - | - |
  230. | **Runs tests** | - | - | ✅ | ✅ | ✅ | - | - | - | ✅ | ✅ |
  231. | **Creates git branches** | - | ✅ | ✅ | - | - | - | - | - | ✅ | - |
  232. | **Creates PRs** | - | ✅ | ✅ | - | - | - | - | - | - | - |
  233. | **Multi-agent parallel** | - | ✅ | ✅ | - | ✅ | ✅ | ✅ | ✅ | - | - |
  234. | **Security scanning** | - | - | - | ✅ | - | ✅ | - | - | - | - |
  235. | **Generates documentation** | - | ✅ | - | - | - | - | ✅ | ✅ | - | - |
  236. | **Constitution enforcement** | ✅ | ✅ | ✅ | ✅ | - | ✅ | - | - | - | - |
  237. | **Drift detection** | - | - | ✅ | - | - | - | - | - | - | - |
  238. | **Code ownership enforcement** | - | - | - | - | ✅ | - | - | - | - | - |
  239. ### When Skills Overlap
  240. **validate vs review** — *Different purposes, different timing*
  241. | Aspect | `/validate` | `/review` |
  242. |--------|-------------------|-----------------|
  243. | **When** | During development | Before merging |
  244. | **Focus** | Spec compliance, quality gates | Code quality, security, performance |
  245. | **Output** | Advisory recommendations | PR comments, findings report |
  246. **analyze vs document** — *Discovery vs generation*
  247. | Aspect | `/analyze` | `/document` |
  248. |--------|------------------|-------------------|
  249. | **Purpose** | Discover what exists | Generate documentation |
  250. | **Output** | Knowledge documentation | API docs, READMEs, JSDoc |
  251. **refactor vs debug** — *Improvement vs fixing*
  252. | Aspect | `/refactor` | `/debug` |
  253. |--------|-------------------|----------------|
  254. | **Behavior** | Must preserve exactly | Expected to change (fix) |
  255. | **Tests** | Must all pass throughout | May need new/updated tests |
  256. ---
  257. ## 📦 Plugins
  258. The Agentic Startup is distributed as **Claude Code marketplace plugins**—native integration with zero manual configuration.
  259. ### Start Plugin (`start@the-startup`)
  260. **Core workflow orchestration** — 10 user-invocable skills, 5 autonomous skills, 2 output styles
  261. | Category | Capabilities |
  262. |----------|-------------|
  263. | **Setup** | Environment configuration (`init`), project governance rules (`constitution`) |
  264. | **Build** | `specify` → `validate` → `implement` pipeline with parallel agent coordination |
  265. | **Quality** | Multi-agent code review, security scanning, constitution enforcement, drift detection |
  266. | **Maintain** | Documentation generation, codebase analysis, safe refactoring, debugging |
  267. | **Git** | Optional branch/commit/PR workflows integrated into skills |
  268. **📖 [View detailed skill documentation →](plugins/start/README.md)**
  269. ### Team Plugin (`team@the-startup`) — *Optional*
  270. **Specialized agent library** — 8 roles, 20 activity-based agents. Now with experimental [Agent Teams](#agent-teams-experimental--new-in-v3) support for multi-agent collaboration.
  271. | Role | Focus Areas |
  272. |------|-------------|
  273. | **Chief** | Complexity assessment, activity routing, parallel execution |
  274. | **Analyst** | Requirements, prioritization, project coordination |
  275. | **Architect** | System design, technology research, quality review, documentation |
  276. | **Software Engineer** | APIs, components, domain modeling, performance |
  277. | **QA Engineer** | Test strategy, exploratory testing, load testing |
  278. | **Designer** | User research, interaction design, design systems, accessibility |
  279. | **Platform Engineer** | IaC, containers, CI/CD, monitoring, data pipelines |
  280. | **Meta Agent** | Agent design and generation |
  281. **📖 [View all available agents →](plugins/team/README.md)**
  282. ---
  283. ## 🎨 Output Styles
  284. The Start plugin includes two output styles that change how Claude communicates while working. Both maintain the same quality standards—the difference is in personality and explanation depth.
  285. **Switch anytime:** `/output-style start:The Startup` or `/output-style start:The ScaleUp`
  286. ### The Startup 🚀
  287. **High-energy execution with structured momentum.**
  288. - **Vibe:** Demo day energy, Y Combinator intensity
  289. - **Voice:** "Let's deliver this NOW!", "BOOM! That's what I'm talking about!"
  290. - **Mantra:** "Done is better than perfect, but quality is non-negotiable"
  291. **Best for:** Fast-paced sprints, high-energy execution, when you want momentum and celebration.
  292. ### The ScaleUp 📈
  293. **Calm confidence with educational depth.**
  294. - **Vibe:** Professional craft, engineering excellence
  295. - **Voice:** "We've solved harder problems. Here's the approach."
  296. - **Mantra:** "Sustainable speed at scale. We move fast, but we don't break things."
  297. **Unique feature — Educational Insights:** The ScaleUp explains decisions as it works:
  298. > 💡 *Insight: I used exponential backoff here because this endpoint has rate limiting. The existing `src/utils/retry.ts` helper already implements this pattern.*
  299. **Best for:** Learning while building, understanding codebase patterns, onboarding to unfamiliar codebases.
  300. ### Comparison
  301. | Dimension | The Startup | The ScaleUp |
  302. |-----------|-------------|-------------|
  303. | **Energy** | High-octane, celebratory | Calm, measured |
  304. | **Explanations** | Minimal—ships fast | Educational insights included |
  305. | **On failure** | "That didn't work. Moving on." | "Here's what failed and why..." |
  306. | **Closing thought** | "What did we deliver?" | "Can the team maintain this?" |
  307. ---
  308. ## 🔧 How Skills Work
  309. The Agentic Startup is built on Claude Code's [skills system](https://code.claude.com/docs/en/skills), which follows the [Agent Skills](https://agentskills.io) open standard. Understanding how skills are invoked helps you get the most out of the framework.
  310. ### Invocation Model
  311. Skills have two invocation paths, controlled by frontmatter fields in each skill's `SKILL.md`:
  312. | Path | How It Works | Controlled By |
  313. |------|-------------|---------------|
  314. | **User slash command** | You type `/skill-name [args]` | `user-invocable` (default: `true`) |
  315. | **Model auto-invocation** | Claude detects context and loads the skill via the Skill tool | `disable-model-invocation` (default: `false`) |
  316. Skills from the Start plugin are invoked directly by name (e.g., `/specify`, `/test`).
  317. ### User-Invocable vs Autonomous Skills
  318. | Type | Visible in `/` menu? | Claude auto-invokes? | Example |
  319. |------|:--------------------:|:--------------------:|---------|
  320. | **User-invocable** | Yes | Yes | `/specify` — you trigger the spec workflow |
  321. | **Autonomous** | No | Yes | `specify-requirements` — loaded by `specify` when creating PRDs |
  322. The user-invocable skills are the ones you interact with directly. The autonomous skills activate behind the scenes when orchestrator skills need them (e.g., `specify` loads `specify-requirements`, `specify-solution`, and `specify-plan` during the specification workflow).
  323. ### Progressive Disclosure
  324. Skills load efficiently to conserve context:
  325. 1. **At startup** — Only skill names and descriptions are loaded (~100 tokens each)
  326. 2. **On invocation** — Full `SKILL.md` content loads when you or Claude triggers the skill
  327. 3. **On demand** — Supporting files (`reference.md`, templates, scripts) load only when needed
  328. This means all 15 skills can be available without consuming significant context until actually used.
  329. ---
  330. ## 📊 Statusline
  331. The installer sets up a custom statusline that displays context usage, session cost, and other useful information directly in your Claude Code terminal.
  332. ### What You See
  333. ```
  334. 📁 ~/C/p/project ⎇ main* 🤖 Opus 4.5 (The Startup) 🧠 ⣿⣿⡇⠀⠀ 50% 🕐 30m 💰 $1.50 ? for shortcuts
  335. ```
  336. | Component | Description |
  337. |-----------|-------------|
  338. | 📁 `~/C/p/project` | Current directory (abbreviated) |
  339. | ⎇ `main*` | Git branch (* indicates uncommitted changes) |
  340. | 🤖 `Opus 4.5 (The Startup)` | Model and output style |
  341. | 🧠 `⣿⣿⡇⠀⠀ 50%` | Context window usage (color-coded) |
  342. | 🕐 `30m` | Session duration |
  343. | 💰 `$1.50` | Session cost (color-coded by plan) |
  344. ### Color Thresholds
  345. Both context usage and cost display color-coded warnings:
  346. | Color | Context | Cost (Pro plan) |
  347. |-------|---------|-----------------|
  348. | 🟢 Green | < 70% | < $1.50 |
  349. | 🟡 Amber | 70-89% | $1.50 - $4.99 |
  350. | 🔴 Red | ≥ 90% | ≥ $5.00 |
  351. ### Configuration
  352. The statusline reads from `~/.config/the-agentic-startup/statusline.toml`:
  353. ```toml
  354. # Format string (customize what's displayed)
  355. format = "<path> <branch> <model> <context> <session> <help>"
  356. # Plan for cost thresholds: "auto" | "pro" | "max5x" | "max20x" | "api"
  357. plan = "auto"
  358. fallback_plan = "pro"
  359. [thresholds.context]
  360. warn = 70 # percentage
  361. danger = 90
  362. [thresholds.cost]
  363. # Uncomment to override plan defaults:
  364. # warn = 2.00
  365. # danger = 5.00
  366. ```
  367. ### Plan-Based Cost Defaults
  368. | Plan | Monthly | Warn | Danger |
  369. |------|---------|------|--------|
  370. | `pro` | $20 | $1.50 | $5.00 |
  371. | `max5x` | $100 | $5.00 | $15.00 |
  372. | `max20x` | $200 | $10.00 | $30.00 |
  373. | `api` | Pay-as-you-go | $2.00 | $10.00 |
  374. ### Format Placeholders
  375. | Placeholder | Description | Example |
  376. |-------------|-------------|---------|
  377. | `<path>` | Abbreviated directory | `~/C/p/project` |
  378. | `<branch>` | Git branch with dirty indicator | `⎇ main*` |
  379. | `<model>` | Model and output style | `🤖 Opus 4.5 (The Startup)` |
  380. | `<context>` | Context usage bar and percentage | `🧠 ⣿⣿⡇⠀⠀ 50%` |
  381. | `<session>` | Duration and cost | `🕐 30m 💰 $1.50` |
  382. | `<lines>` | Lines added/removed | `+156/-23` |
  383. | `<spec>` | Active spec ID (when in .start/specs/) | `📋 005` |
  384. | `<help>` | Help text | `? for shortcuts` |
  385. **Example minimal format:**
  386. ```toml
  387. format = "<context> <session>"
  388. ```
  389. ---
  390. ## 💡 Why The Agentic Startup?
  391. Real workflow features that solve real problems — not just another AI wrapper.
  392. ### Resume Across Sessions
  393. Hit a context limit? Start a new conversation and pick up exactly where you left off. Specs persist on disk — Claude reads them and continues.
  394. ```bash
  395. /specify 001 # ← resumes spec creation from where you left off
  396. /implement 001 # ← resumes implementation, tracking progress in spec files
  397. ```
  398. ### Code Ownership Mandate
  399. No more "pre-existing failure" excuses. When `/test` finds a failing test, it fixes it — period. You touched the codebase, you own it.
  400. ### Drift Detection
  401. Implementation drifting from the spec? Caught automatically during `/implement`. Scope creep, missing items, contradictions — flagged with options to update the spec or the code.
  402. ### Adaptive Code Review
  403. `/review` auto-detects what matters. Async code triggers concurrency review. Dependency changes trigger supply-chain checks. UI changes trigger accessibility audits. 5 base perspectives + conditional specialists.
  404. ### Non-Linear Specs
  405. Skip what you don't need. Start with a solution design, jump straight to decomposition, or go full requirements → solution → plan. Skipped phases are logged as decisions, not gaps.
  406. ### Adversarial Debugging
  407. Tough bugs get multiple investigators that actively try to disprove each other's hypotheses. The surviving theory is most likely the root cause — competing hypotheses, not confirmation bias.
  408. ### Agent Teams (Experimental) — New in v3
  409. Enable multi-agent collaboration where specialized agents coordinate autonomously on complex tasks. The installer configures this automatically, or enable manually:
  410. ```json
  411. // ~/.claude/settings.json
  412. {
  413. "env": {
  414. "CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS": "1"
  415. }
  416. }
  417. ```
  418. ---
  419. ## 🎯 Philosophy
  420. Research shows **2-22% accuracy improvement** with specialized task agents vs. single broad agents ([Multi-Agent Collaboration, 2025](https://arxiv.org/html/2501.06322v1)). Leading frameworks organize agents by **capability**, not job titles. The Agentic Startup applies this research through activity-based specialization.
  421. ### The Problem We Solve
  422. Development often moves too fast without proper planning:
  423. - Features built without clear requirements
  424. - Architecture decisions made ad-hoc during coding
  425. - Technical debt accumulates from lack of upfront design
  426. - Teams struggle to maintain consistency across implementations
  427. ### Our Approach
  428. **1. Specify First** — Create comprehensive specifications before writing code
  429. - **Requirements** — What to build and why
  430. - **Solution** — How to build it technically
  431. - **Plan** — The phases and their slices, with holdout acceptance scenarios per slice
  432. **2. Review & Refine** — Validate specifications with stakeholders
  433. - Catch issues during planning, not during implementation
  434. - Iterate on requirements and design cheaply
  435. - Get alignment before costly development begins
  436. **3. Implement with Confidence** — Execute validated plans task by task
  437. - Clear acceptance criteria at every step
  438. - Parallel agent coordination for speed
  439. - Built-in validation gates and quality checks
  440. **4. Document & Learn** — Capture patterns for future reuse
  441. - Automatically document discovered patterns
  442. - Build organizational knowledge base
  443. - Prevent reinventing solutions
  444. ### Core Principles
  445. - **Measure twice, cut once** — Investing time in specifications saves exponentially more time during implementation.
  446. - **Documentation as code** — Specs, patterns, and interfaces are first-class artifacts that evolve with your codebase.
  447. - **Parallel execution** — Multiple specialists work simultaneously within clear boundaries, maximizing velocity without chaos.
  448. - **Quality gates** — Definition of Ready (DOR) and Definition of Done (DOD) ensure standards are maintained throughout.
  449. - **Progressive disclosure** — Skills and agents load details only when needed, optimizing token efficiency while maintaining power.
  450. ---
  451. ## 📚 Documentation
  452. ### Patterns
  453. Reusable architectural patterns and design decisions:
  454. | Pattern | Description |
  455. |---------|-------------|
  456. | [Slim Agent Architecture](docs/patterns/slim-agent-architecture.md) | Structure agents to maximize effectiveness while minimizing context usage |
  457. ### Additional Resources
  458. - [Start Plugin Documentation](plugins/start/README.md) — Workflow skills
  459. - [Team Plugin Documentation](plugins/team/README.md) — Specialized agents and skills library
  460. - [Migration Guide](MIGRATION.md) — Upgrading from v1.x
  461. ---
  462. <p align="center">
  463. <strong>Ready to 10x your development workflow?</strong><br>
  464. Let's ship something incredible! 🚀
  465. </p>

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.