Design Team Workflow System

An AI-powered design thinking workflow system with specialized agents that guide projects through research, ideation, and validation phases.

What This Skill Does

This skill implements a complete design thinking workspace where AI agents collaborate to guide projects through structured design phases. It provides:

**Three specialized agent personas** that handle different aspects of design work

**Reusable design thinking skills** for empathy mapping, assumption validation, insight synthesis, and more

**Project state management** tracking progress through design phases

**Custom tool system** for file operations and state management

**Structured artifacts** for research, ideas, and stakeholder feedback

Repository Structure

The design system workspace contains:

**Agent definitions** in `.github/agents/` — AI agent personas (Stakeholders, DesignTeam, LT)

**Design skills** in `.github/skills/` — Reusable design thinking methods

**Project templates** in `templates/` — Structures for new design projects

**Data schemas** in `schemas/` — JSON schemas for project state

**Active projects** in `projects/` — Actual design work created by users

Instructions

1. Understand the Design Thinking Phases

Projects move through five phases:

1. **Empathize** — Research user needs and pain points

2. **Define** — Articulate problems and validate assumptions

3. **Ideate** — Generate and evaluate solution concepts

4. **Prototype** — Build testable versions of ideas

5. **Iterate** — Refine based on feedback and validation

Each phase has specific activities, artifacts, and decision gates before progressing.

2. Use the Specialized Agents

Three agent personas are available for different tasks:

**@DesignTeam** — Five designers guiding the design process (use for most design work)

- Conducts research activities

- Synthesizes insights

- Generates and evaluates ideas

- Creates prototypes

**@Stakeholders** — User representatives providing authentic feedback

- Shares needs and pain points

- Validates assumptions

- Tests prototypes

- Provides realistic user perspectives

**@LT** (Leadership Team) — Strategic decision-makers at phase gates

- Reviews phase completion

- Makes go/no-go decisions

- Allocates resources

- Approves direction changes

See `.github/agents/README.md` for complete agent documentation.

3. Apply Reusable Skills

Agents use skills from `.github/skills/` including:

**empathy-mapping** — Map user feelings, thoughts, actions, pain points

**needs-articulation** — Define clear, specific user needs

**assumption-grading** — Rate assumptions by certainty and risk

**assumption-validation** — Test critical assumptions with evidence

**insight-synthesis** — Extract patterns from research data

**idea-evaluation** — Score ideas on impact and feasibility

**prototype-planning** — Plan testable prototypes

**playback-preparation** — Prepare stakeholder presentations

4. Work with Project State

Every project has `projects/[name]/currentstate.json` as the central index containing:

Current phase

Assumptions with certainty/risk grades

Stakeholders with needs/pain points

Research plan and insights

Ideas with impact/feasibility grades

Playback decisions

**IMPORTANT:** Always read `currentstate.json` first to understand project context before making changes.

5. Manage Project Artifacts

Projects organize work into directories:

`insights/` — Research notes, observations, interviews, synthesis documents

`ideas/` — Solution concepts and prototype iterations

`playbacks/` — Leadership presentations and decisions

Keep artifacts aligned with the current phase and update `currentstate.json` to reflect progress.

6. Use Custom Tools

This repository uses custom Python tools via `scripts/tool_runner.py` for all file operations and state management. Agents access these tools using the `execute` tool to run Python scripts.

Common operations:

Read project state

Update assumptions

Add research insights

Grade ideas

Transition between phases

See `docs/CUSTOM_TOOLS.md` for:

Tool architecture and usage patterns

Complete list of read and edit operations

Standardized JSON response format

Integration with agents

7. Follow Design Thinking Principles

When working in this repository:

**Focus on user needs, not features** — Start with problems, not solutions

**Validate assumptions before commitments** — Test risky assumptions early

**Document reasoning and evidence** — Record why decisions were made

**Use phases systematically** — Don't skip steps in the design process

**Keep currentstate.json up to date** — Maintain accurate project state

8. Navigate Path-Specific Instructions

For specific file types and directories, consult path-specific instructions in `.github/instructions/` to understand special handling requirements.

Example Usage

**Starting a new project:**

1. Use project template to create structure in `projects/[name]/`

2. Initialize `currentstate.json` with phase "Empathize"

3. Invoke @Stakeholders to gather initial needs

4. Use @DesignTeam to conduct empathy mapping

5. Document findings in `insights/`

**Progressing through phases:**

1. Complete phase activities using appropriate skills

2. Update `currentstate.json` with findings

3. Prepare playback presentation

4. Request @LT review at phase gate

5. Transition to next phase upon approval

**Validating assumptions:**

1. Read `currentstate.json` to identify high-risk assumptions

2. Use assumption-validation skill with @DesignTeam

3. Gather evidence from @Stakeholders

4. Update assumption grades in state

5. Document validation results in `insights/`

Constraints

Always read `currentstate.json` before modifying project state

Use custom tools via `scripts/tool_runner.py` for file operations

Follow phase sequence — don't skip design thinking phases

Involve appropriate agents for their specialized roles

Document all decisions and evidence in project artifacts

Keep project state synchronized across all files

Documentation

For more information:

Agent personas: `.github/agents/README.md`

Skills library: `.github/skills/`

Custom tools: `docs/CUSTOM_TOOLS.md`

Path-specific instructions: `.github/instructions/`

Design Team Workflow System

Design Team Workflow System

What This Skill Does

Repository Structure

Instructions

1. Understand the Design Thinking Phases

2. Use the Specialized Agents

3. Apply Reusable Skills

4. Work with Project State

5. Manage Project Artifacts

6. Use Custom Tools

7. Follow Design Thinking Principles

8. Navigate Path-Specific Instructions

Example Usage

Constraints

Documentation

Reviews (0)