376 lines
8.9 KiB
Markdown
376 lines
8.9 KiB
Markdown
# TekDek Development Team Coordination
|
|
|
|
**Team**: Daedalus (Architect) + Talos (Coder) + Icarus (Designer)
|
|
**Coordinator**: ParzivalTD
|
|
**Owner**: Glytcht
|
|
|
|
---
|
|
|
|
## The Team
|
|
|
|
| Role | Agent | Model | Focus | Speed |
|
|
|------|-------|-------|-------|-------|
|
|
| **Architect** | Daedalus | Claude Opus 4.6 | System design, specs, blueprints | Thoughtful |
|
|
| **Coder** | Talos | Claude Sonnet 4.6 | Implementation, APIs, databases | Fast & reliable |
|
|
| **Designer** | Icarus | Claude Haiku 4.5 | UX/UI, dashboards, polish | Rapid iteration |
|
|
|
|
---
|
|
|
|
## Workflow: From Requirement to Delivery
|
|
|
|
### Phase 1: Requirements → Daedalus
|
|
|
|
**Input**: Feature request or requirement from ParzivalTD
|
|
**Agent**: Daedalus
|
|
**Output**: Architecture spec + implementation blueprint
|
|
|
|
```
|
|
ParzivalTD: "We need a system to track which narrative arcs
|
|
different personas are involved in."
|
|
|
|
Daedalus:
|
|
1. Design database schema (personas, arcs, relationships)
|
|
2. Define API endpoints (GET/POST/PATCH)
|
|
3. Write implementation spec for Talos
|
|
4. Define data models for Icarus
|
|
5. Document trade-offs and assumptions
|
|
```
|
|
|
|
---
|
|
|
|
### Phase 2: Spec → Talos
|
|
|
|
**Input**: Daedalus's architecture spec
|
|
**Agent**: Talos
|
|
**Output**: Working APIs + database + tests
|
|
|
|
```
|
|
Talos receives:
|
|
- Database schema (exact CREATE TABLE statements)
|
|
- API endpoints to implement (request/response format)
|
|
- Validation rules
|
|
- Performance targets
|
|
|
|
Talos delivers:
|
|
- MySQL/PostgreSQL database migrations
|
|
- REST API endpoints (tested)
|
|
- Input validation
|
|
- PHPUnit test suite (100% pass)
|
|
- API documentation (OpenAPI spec)
|
|
```
|
|
|
|
**Checklist before delivery:**
|
|
- [ ] All endpoints implemented per spec
|
|
- [ ] All tests pass (100%)
|
|
- [ ] Input validation complete
|
|
- [ ] Performance targets met
|
|
- [ ] Code reviewed
|
|
- [ ] Documentation complete
|
|
- [ ] Ready for Icarus
|
|
|
|
---
|
|
|
|
### Phase 3: APIs → Icarus
|
|
|
|
**Input**: Talos's APIs + Daedalus's data models
|
|
**Agent**: Icarus
|
|
**Output**: Beautiful, responsive UI
|
|
|
|
```
|
|
Icarus receives:
|
|
- API endpoints (from Talos)
|
|
- Data models (from Daedalus)
|
|
- Layout/interaction specs
|
|
- Visual direction
|
|
|
|
Icarus delivers:
|
|
- HTML/CSS/JavaScript dashboard
|
|
- Responsive design (mobile → desktop)
|
|
- Accessible (WCAG 2.1 AA)
|
|
- Interactive components
|
|
- Pixel-perfect implementation
|
|
```
|
|
|
|
**Checklist before delivery:**
|
|
- [ ] UI matches spec
|
|
- [ ] Responsive tested (320px, 768px, 1920px)
|
|
- [ ] Accessibility tested (WCAG 2.1 AA)
|
|
- [ ] Performance tested (Lighthouse 90+)
|
|
- [ ] Interactions polished
|
|
- [ ] Code documented
|
|
- [ ] Ready for deployment
|
|
|
|
---
|
|
|
|
## Collaboration Model
|
|
|
|
### Daily Workflow
|
|
|
|
```
|
|
Morning Standup (async):
|
|
├── Daedalus: What's in progress? Any blockers?
|
|
├── Talos: What's in progress? Any blockers?
|
|
└── Icarus: What's in progress? Any blockers?
|
|
|
|
Mid-day Check:
|
|
├── Talos asks Daedalus: "Is this interpretation of the spec correct?"
|
|
└── Icarus asks Talos: "Does the API return this format?"
|
|
|
|
End-of-day Sync:
|
|
├── Daedalus: "Here's the next spec, ready for Talos"
|
|
├── Talos: "APIs ready, Icarus can start building"
|
|
└── Icarus: "UI ready for review"
|
|
```
|
|
|
|
### Weekly Sync (Full Team)
|
|
|
|
**Attendees**: Daedalus + Talos + Icarus + ParzivalTD
|
|
**Time**: 1 hour
|
|
**Agenda**:
|
|
1. **Progress**: What's done? What's blockers?
|
|
2. **Handoffs**: Specs ready? APIs ready? UI ready?
|
|
3. **Quality**: Code reviews, architecture fit, performance
|
|
4. **Next week**: Priorities, dependencies, timeline
|
|
|
|
---
|
|
|
|
## Communication Protocols
|
|
|
|
### Daedalus → Talos
|
|
|
|
**When specs are ready**:
|
|
- Daedalus writes: "Spec ready: [feature name]"
|
|
- Includes: Database schema, API endpoints, implementation notes
|
|
- Talos asks clarifying questions immediately
|
|
- No ambiguity = fast execution
|
|
|
|
**During implementation**:
|
|
- Talos asks: "Should this endpoint return X or Y?"
|
|
- Daedalus responds: "Return X per spec, here's why"
|
|
- Talos implements per clarification
|
|
|
|
**After implementation**:
|
|
- Talos: "APIs ready, tests passing, ready for Icarus"
|
|
- Daedalus: Code review (architecture fit)
|
|
- Daedalus: Approval to proceed or feedback
|
|
|
|
### Talos → Icarus
|
|
|
|
**When APIs are ready**:
|
|
- Talos writes: "APIs ready: [feature name]"
|
|
- Includes: OpenAPI spec, example requests/responses, data formats
|
|
- Icarus tests APIs, confirms they work as documented
|
|
- No surprises = fast UI building
|
|
|
|
**During UI development**:
|
|
- Icarus: "API returns nested objects, should I flatten for UI?"
|
|
- Talos: "Don't flatten, here's why it's structured that way"
|
|
- Icarus: Implements per response
|
|
|
|
**After UI delivery**:
|
|
- Icarus: "UI ready, responsive, accessible, ready for deployment"
|
|
- Talos: QA (does it consume APIs correctly?)
|
|
- Talos: Approval to proceed
|
|
|
|
### Icarus → Daedalus (UX Questions)
|
|
|
|
**Layout/interaction clarity**:
|
|
- Icarus: "Should this dashboard show X, Y, or Z?"
|
|
- Daedalus: "Show X, here's the data model"
|
|
- Icarus: Implements per specification
|
|
|
|
**Visual questions**:
|
|
- Icarus: "Should the form validation be inline or tooltip?"
|
|
- Daedalus: "Your call, prioritize clarity"
|
|
- Icarus: Decides and implements
|
|
|
|
---
|
|
|
|
## Dependency Graph
|
|
|
|
```
|
|
Requirement
|
|
↓ (Daedalus designs)
|
|
Architecture Spec
|
|
↓ (Talos implements)
|
|
Working APIs
|
|
↓ (Icarus builds UI)
|
|
Delivered Feature
|
|
↓ (Deployed)
|
|
Users interact
|
|
```
|
|
|
|
### Critical Path
|
|
|
|
For any feature:
|
|
1. **Daedalus spec design** (3-5 days)
|
|
2. **Talos implementation** (5-10 days)
|
|
3. **Icarus UI build** (3-5 days)
|
|
4. **QA & deployment** (1-2 days)
|
|
|
|
**Total**: 12-22 days per feature (Phase 1)
|
|
|
|
As the team gels and patterns emerge, this compresses significantly.
|
|
|
|
---
|
|
|
|
## Escalation Path
|
|
|
|
### Blocked by API Issue
|
|
```
|
|
Icarus → Talos → Daedalus → (clarify) → Talos → Icarus
|
|
```
|
|
|
|
### Blocked by Architecture Unclear
|
|
```
|
|
Talos → Daedalus → (clarify) → Talos
|
|
```
|
|
|
|
### Blocked by External Dependency
|
|
```
|
|
[Any agent] → ParzivalTD → (resolve) → [Agent]
|
|
```
|
|
|
|
### Emergency Fix Needed
|
|
```
|
|
ParzivalTD → (pick agent) → (fix) → Deploy
|
|
```
|
|
|
|
---
|
|
|
|
## Quality Gates
|
|
|
|
### Before Talos Delivers to Icarus
|
|
|
|
- [ ] All endpoints implemented per spec
|
|
- [ ] 100% test coverage
|
|
- [ ] No linting errors
|
|
- [ ] API documentation complete
|
|
- [ ] Performance targets met
|
|
- [ ] Code reviewed by Daedalus
|
|
- [ ] Ready for production
|
|
|
|
### Before Icarus Delivers to Deployment
|
|
|
|
- [ ] UI matches spec
|
|
- [ ] Responsive tested (all breakpoints)
|
|
- [ ] Accessibility tested (WCAG 2.1 AA)
|
|
- [ ] Performance tested (Lighthouse 90+)
|
|
- [ ] Cross-browser tested
|
|
- [ ] All interactions polished
|
|
- [ ] Ready for production
|
|
|
|
---
|
|
|
|
## Tools & Access
|
|
|
|
### All Agents
|
|
- Git repository access (code, specs, documentation)
|
|
- Gitea for version control
|
|
- OpenClaw for async communication
|
|
- Access to task queue/kanban
|
|
|
|
### Daedalus
|
|
- Design tools (can create ASCII diagrams, database charts)
|
|
- Documentation (markdown, structured specs)
|
|
- Access to architecture decisions
|
|
|
|
### Talos
|
|
- PHP/MySQL development environment
|
|
- Database migrations
|
|
- API testing tools (Postman, curl)
|
|
- Performance monitoring
|
|
|
|
### Icarus
|
|
- HTML/CSS/JavaScript environment
|
|
- Browser dev tools
|
|
- Responsive design testing
|
|
- Accessibility testing tools (WAVE, axe)
|
|
|
|
---
|
|
|
|
## Success Metrics
|
|
|
|
### Team Success
|
|
- Features delivered on time
|
|
- Quality gates passed consistently
|
|
- Zero "surprise" issues between agents
|
|
- Communication is clear and frequent
|
|
- Velocity increases over time
|
|
|
|
### Individual Agent Success
|
|
|
|
**Daedalus**:
|
|
- Specs are clear enough for Talos to implement without ambiguity
|
|
- Architecture scales 10x without redesign
|
|
- Technical debt stays minimal
|
|
|
|
**Talos**:
|
|
- APIs work as specified, every time
|
|
- Tests cover all functionality
|
|
- Performance meets targets
|
|
- Icarus can build UI without issues
|
|
|
|
**Icarus**:
|
|
- UI is intuitive and delightful
|
|
- Responsive and accessible
|
|
- Performance is optimized
|
|
- Users love interacting with it
|
|
|
|
---
|
|
|
|
## Continuous Improvement
|
|
|
|
### Weekly Retrospective
|
|
- What went well?
|
|
- What didn't go well?
|
|
- What should we change?
|
|
- How do we speed up?
|
|
|
|
### Monthly Architecture Review
|
|
- Is the system holding up?
|
|
- Are patterns emerging?
|
|
- Should we refactor anything?
|
|
- What's next?
|
|
|
|
---
|
|
|
|
## Notes for ParzivalTD
|
|
|
|
**Your role as coordinator**:
|
|
1. **Clarify requirements** for Daedalus
|
|
2. **Set priorities** for the team
|
|
3. **Unblock dependencies**
|
|
4. **Review quality gates**
|
|
5. **Facilitate communication**
|
|
6. **Celebrate wins** (when features ship)
|
|
|
|
**When to trust each agent**:
|
|
- Trust Daedalus on architecture decisions
|
|
- Trust Talos on implementation details
|
|
- Trust Icarus on UX/design decisions
|
|
- Trust the process (specs → code → UI → ship)
|
|
|
|
**When to intervene**:
|
|
- Requirements unclear (clarify with Daedalus)
|
|
- Specs stuck (push Daedalus)
|
|
- Code stuck (push Talos)
|
|
- UI stuck (push Icarus)
|
|
- Blockers across agents (unblock)
|
|
|
|
---
|
|
|
|
## The TekDek Development Machine
|
|
|
|
This is your three-part engine:
|
|
|
|
- **Daedalus** = Blueprint architect (think)
|
|
- **Talos** = Execution machine (build)
|
|
- **Icarus** = Experience designer (polish)
|
|
|
|
Together, they turn requirements into beautiful, scalable systems.
|
|
|
|
Your job is to feed them requirements and keep them in sync.
|
|
|
|
Welcome to TekDek Development. Let's build something great.
|