# 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.
