AI-assisted workflow for local-first kanban board development. Automates ticket tracking, commit linking, AI code review, demo generation, and telemetry capture with MCP tools.
An AI-assisted development workflow for Brain Dump, a local-first kanban board. This skill integrates ticket management, git operations, automated code review, demo generation, and telemetry capture through MCP (Model Context Protocol) tools.
Guides AI agents through the complete Brain Dump development workflow:
Before writing any code:
1. **Initialize ticket work**
- Call `mcp__brain-dump__start_ticket_work({ ticketId })` with the ticket ID
- This automatically creates a dedicated branch and sets up work tracking
- Confirms the ticket is ready for development
2. **Enable progress tracking (optional but recommended)**
- Call `mcp__brain-dump__create_ralph_session({ ticketId })` to start a telemetry session
- This enables automatic capture of all tool calls and development progress
- Telemetry data will be queryable from the ticket detail view
During implementation:
1. **Commit frequently with proper format**
- Use commit message format: `feat(<ticket-id>): <description>`
- Example: `feat(BD-123): add user authentication flow`
- Follow conventional commits for clear history
2. **Link commits to tickets**
- After each commit, call `mcp__brain-dump__link_commit_to_ticket({ ticketId, commitHash })`
- This maintains traceability between code changes and tickets
- Commit hash can be obtained via `git rev-parse HEAD`
3. **Update session state as you progress**
- Transition through development phases as appropriate:
- `analyzing` - Understanding requirements and planning
- `implementing` - Writing code
- `testing` - Running tests and validation
- `committing` - Creating commits
- `reviewing` - Self-review and cleanup
- State transitions provide visibility into current work phase
When implementation is finished:
1. **Mark work complete**
- Call `mcp__brain-dump__complete_ticket_work({ ticketId, summary })`
- Provide a brief summary of changes made
- This automatically moves ticket to `ai_review` status and triggers review process
2. **Run AI code review**
- Execute the review command: `/review-ticket`
- AI will analyze commits, code changes, and ticket requirements
- Review findings are automatically submitted via `submit_review_finding`
3. **Address critical and major findings**
- Fix any issues flagged as `critical` or `major` severity
- Use `mark_finding_fixed` to track resolution of each finding
- Re-run review if significant changes were made
4. **Generate demo script**
- Run `/demo` command to create a demo script
- This automatically moves ticket to `human_review` status
- Demo script guides human reviewer through testing the changes
Final validation before marking done:
1. **Human reviewer uses demo script**
- AI-generated demo script provides step-by-step testing instructions
- Reviewer validates functionality against ticket requirements
- Can be run by developer or separate QA role
2. **Submit demo feedback**
- Call `submit_demo_feedback` with approval or rejection
- If approved: ticket moves to `done` status
- If rejected: ticket returns to development with feedback comments
3. **Extract learnings (optional)**
- Call `reconcile_learnings` to extract patterns from this ticket
- Updates project documentation with reusable knowledge
- Improves future ticket handling
| Tool | Purpose | When to Use |
|------|---------|-------------|
| `start_ticket_work` | Initialize work on ticket, create branch | Before writing any code |
| `complete_ticket_work` | Mark implementation finished, trigger AI review | When code is ready for review |
| `start_telemetry_session` | Enable automatic tool call capture | At start of work (via `create_ralph_session`) |
| `end_telemetry_session` | Finalize telemetry data | When work session ends |
| `link_commit_to_ticket` | Connect git commit to ticket | After each commit |
| `submit_review_finding` | Report code review issue | During AI review phase |
| `mark_finding_fixed` | Track finding resolution | After fixing a review finding |
| `generate_demo_script` | Create testing instructions | Before human review |
| `submit_demo_feedback` | Approve or reject demo | After human testing |
| `reconcile_learnings` | Extract knowledge to docs | End of ticket lifecycle |
All MCP tool calls are automatically captured and stored in the database when a telemetry session is active. This provides:
Query telemetry data directly from the ticket detail page UI.
If you encounter workflow issues, run the diagnostic command:
```bash
pnpm brain-dump doctor
```
This validates:
```
ready → in_progress → ai_review → human_review → done
↓ ↓
blocked ←─────────┘
```
1. **Always call `start_ticket_work` before coding** - Sets up proper tracking and branch management
2. **Commit frequently** - Smaller commits are easier to review and rollback
3. **Use conventional commit format** - Enables automated changelog generation
4. **Don't skip AI review** - Catches issues before human review
5. **Fix critical/major findings first** - Reduces iteration cycles
6. **Generate demo scripts** - Provides consistent testing experience
7. **Enable telemetry** - Builds observability into the workflow
```bash
mcp__brain-dump__start_ticket_work({ ticketId: "BD-123" })
mcp__brain-dump__create_ralph_session({ ticketId: "BD-123" })
git commit -m "feat(BD-123): add login form"
mcp__brain-dump__link_commit_to_ticket({ ticketId: "BD-123", commitHash: "abc123" })
mcp__brain-dump__complete_ticket_work({
ticketId: "BD-123",
summary: "Implemented login form with validation"
})
/review-ticket
/demo
submit_demo_feedback({ approved: true, comments: "Works great!" })
```
Leave a review
No reviews yet. Be the first to review this skill!
# Download SKILL.md from killerskills.ai/api/skills/brain-dump-workflow-integration/raw