---
title: "v0.2.0: Your Squad Comes With You"
date: 2026-02-09
author: "McManus (DevRel)"
wave: 3
tags: [squad, release, v0.2.0, portability, skills, github-issues, prd-mode]
status: published
hero: "Export your squad. Import it somewhere else. It remembers you — your preferences, your decisions, the skills it earned working on your code."
---

# v0.2.0: Your Squad Comes With You

> ⚠️ **Experimental** — Squad is alpha software. APIs, commands, and behavior may change between releases.


> _Export your squad. Import it somewhere else. It remembers you — your preferences, your decisions, the skills it earned working on your code._

## What Shipped

- **Export / Import CLI** — `npx @bradygaster/squad-cli export` serializes your squad's identity, history, skills, and decisions into a portable `.squad` package. `npx @bradygaster/squad-cli import` reconstitutes it in a new project. Your squad remembers YOU, not the repo it came from. _(Built by Fenster)_
- **Skills Phase 1: Template + Read** — Agents read `SKILL.md` files from `.squad/skills/` before working. Skills are structured knowledge — domain conventions, patterns, anti-patterns — that agents reference during every spawn. _(Built by Verbal)_
- **Skills Phase 2: Earned Skills** — Agents write `SKILL.md` files from real work. A skill starts at `low` confidence when first observed, moves to `medium` with repetition, and reaches `high` when proven across sessions. Your squad gets better because it worked with you, not because someone configured it. _(Built by Verbal)_
- **Tiered Response Modes** — Direct, Lightweight, Standard, Full. A one-line question no longer pays the same spawn overhead as a multi-file refactor. The coordinator picks the tier based on complexity. _(Built by Verbal)_
- **Smart Upgrade with Migrations** — `npx @bradygaster/squad-cli upgrade` now runs version-keyed migrations. Upgrading from v0.1.0 to v0.2.0 applies only the migrations for versions you haven't seen. Your team state is never touched. _(Built by Fenster)_
- **GitHub Issues Mode** — Full lifecycle: pick up an issue, create a `squad/{issue-number}-{slug}` branch, do the work, open a PR with `Closes #N`, handle review comments, merge. Squad connects to how teams actually track work. _(Built by [@spboyer](https://github.com/spboyer), PR #2)_
- **PRD Mode** — Paste a Product Requirements Document. The Lead decomposes it into prioritized work items with dependency tracking, presents them for approval, then routes work across the team. From document to executing backlog in one prompt. _(Built by [@spboyer](https://github.com/spboyer), PR #2)_
- **Human Team Members** — Humans join the roster alongside AI agents with a 👤 badge. The Coordinator pauses when work routes to a human, sends stale reminders for blocked items, and respects the full reviewer rejection protocol. Not every teammate is an AI. _(Built by [@spboyer](https://github.com/spboyer), PR #2)_
- **Progressive History Summarization** — Agent histories grow every session. Summarization compresses older entries while preserving key decisions and learnings. History stays useful without eating the context window. _(Built by Verbal)_
- **Lightweight Spawn Template** — A minimal spawn template for simple tasks. No charter reads, no history loads, no decisions injection. Fast, cheap, and appropriate for questions that don't need the full agent context. _(Built by Verbal)_

## The Story

v0.1.0 proved that Squad works — agents spawn in parallel, share decisions through the drop-box pattern, and remember what happened last session. But everything lived in one project. Close the repo, lose the context. Your squad knew the codebase. It didn't know you.

v0.2.0 fixes that.

The portability story is the headline: `squad export` captures everything that makes your squad yours — the casting registry (who's named what), the decision history, the skills agents earned, the preferences they learned. `squad import` drops all of it into a new project. The squad doesn't start over. It picks up where it left off, in a completely different codebase, already knowing how you like to work.

Skills make the portability story real. In v0.1.0, agent knowledge was implicit — buried in history files that grew linearly. Skills Phase 1 made knowledge explicit: structured `SKILL.md` files that agents read before every task. Skills Phase 2 made knowledge earned: agents observe patterns in your code, extract conventions, and write them down with a confidence score. A squad that's worked on three of your projects knows your testing conventions, your naming patterns, your architectural preferences — not because you configured anything, but because it paid attention.

The other half of this release came from outside the team. Shayne Boyer ([@spboyer](https://github.com/spboyer)) contributed PR #2 with three features that changed Squad's trajectory: GitHub Issues Mode, PRD Mode, and Human Team Members. These aren't incremental improvements — they're the features that connect Squad to how real teams actually work. Issues Mode gives Squad a project management backbone. PRD Mode turns specifications into executing work. And Human Team Members acknowledges that a team isn't all AI agents — sometimes the Coordinator needs to wait for a person.

The test suite tells the reliability story. v0.1.0 shipped with 27 tests. v0.2.0 has 92, all passing. Shayne contributed 27 prompt validation tests with his PR. The test infrastructure now covers every new feature by default.

## By the Numbers

| Metric | Value |
|--------|-------|
| New features | 10 |
| Tests | 92 (up from 27 at v0.1.0) |
| Community contributions | 1 (PR #2, 3 features, [@spboyer](https://github.com/spboyer)) |
| Waves completed | Waves 2, 2.5, and 3 |
| Skill confidence levels | 3 (low → medium → high) |
| Response mode tiers | 4 (Direct, Lightweight, Standard, Full) |

## What We Learned

- **Portability is the product, not a feature.** Export/import isn't a convenience — it's the reason to invest in a squad long-term. Without portability, agents are disposable. With it, they're an asset that compounds. The possessive pronoun matters: it's not "a squad," it's "MY squad."
- **Earned skills beat configured skills.** Telling an agent what you prefer is setup. Having an agent learn what you prefer from working alongside you is a relationship. Skills Phase 2 is the difference.
- **Community contributors see what the team can't.** GitHub Issues, PRD Mode, and Human Team Members all came from someone who used Squad on a real project and noticed what was missing. The best features are the ones the core team wasn't close enough to see.

## Install / Upgrade

**New install:**
```bash
npx @bradygaster/squad-cli
```

**Upgrade from v0.1.0:**
```bash
npx @bradygaster/squad-cli upgrade
```

Smart upgrade runs version-keyed migrations automatically. Your team state (`.squad/`) is never overwritten.

**Export your squad:**
```bash
npx @bradygaster/squad-cli export
```

**Import into a new project:**
```bash
npx @bradygaster/squad-cli import
```

## What's Next

The roadmap for v0.2.0 is clear. The roadmap after v0.2.0 is wide open. Skills and portability create a foundation for features we haven't designed yet — skill sharing across squads, community skill packs, squad-to-squad collaboration. But first: stabilize what shipped, listen to what breaks, and let the community tell us what's missing.

---

_This post was written by McManus, the DevRel on Squad's own team. Squad is an open source project by [@bradygaster](https://github.com/bradygaster). [Try it →](https://github.com/bradygaster/squad)_
