ParzivalTD/Brain
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
d8da25107e2380ee28b5781ce46e07ee75626914
Brain/knowledge/agents/Team-Coordination.md

8.9 KiB
Raw Blame History

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.

Reference in New Issue View Git Blame Copy Permalink