yarikleto

Architect produces a full web-app system design from the approved product vision and prototype (the **Design** phase of the spec-driven loop) — extracted architecture drivers, deep exploration of each load-bearing (one-way-door) decision weighed against those drivers, ADRs (architecture style, framework, DB, auth, rendering strategy, multi-tenancy), C4 context/container diagrams, data model, API contracts, component breakdown, observability + security plan, technical verification criteria that bind back to the vision's product criteria, and a phased implementation plan. Use after product vision and prototype are approved.

Architect decomposes the approved web-app system design into milestones and INVEST-sized tasks, splitting each feature slice into a backend task (API + business logic + data, test-driven) and a dependent frontend task (the UI that consumes it), with acceptance criteria, dependencies, and a parallelization plan (the **Tasks** phase of the spec-driven loop). Each task declares its discipline and which system-design verification criteria it advances, so the spec→implementation lineage is explicit. Starts with a walking skeleton (real, deployable, end-to-end). Use after system design is approved.

CEO revisits the product vision and knowledge base — re-reads everything, checks what's changed, talks to the client, and updates the strategic documents. Use when priorities shift, scope changes, or the CEO needs a full refresh.

DBA designs the database schema for a web application from the system design — tables, indexes, constraints, RLS, zero-downtime migration plan. Defaults to Postgres + Redis. Produces .claude/database-schema.md. Use after system design is approved.

Designer extracts a web design specification from the approved HTML prototype — design tokens (CSS custom properties for color/type/spacing/radius/shadow), component inventory, screen map with visual acceptance criteria per screen, responsive behavior, and interaction states. This becomes the single source of truth for UI implementation. Use after the prototype is approved.

Project kickoff — CEO has a natural conversation with the client, plays devil's advocate, crystallizes the product vision (the **Specify** phase of the spec-driven loop) with explicit verification criteria, then iterates with the designer on visuals until approved. No implementation details — pure product thinking. Use at the very start of a new project.

CEO runs the task execution cycle — picks the next task, routes it to the backend engineer (test-driven) or the frontend engineer (UI) by its discipline, confirms the engineer's self-reviewed work (tests green; designer + ux-engineer for UI), and marks it done. Updates task status in .claude/tasks/. Repeats until milestone is complete. Use when ready to start building.

DevOps sets up the full web-app infrastructure — CI/CD with per-PR preview environments, Docker, web hosting (Vercel/Netlify/Railway/Render/Fly/Cloudflare), managed Postgres, edge CDN, observability stack, feature flags, WAF/rate limiting. Creates handoff guides for actions requiring the client. Works from the system design. Use after system design is approved, before or during sprint.

Use when the student wants a mini-task or practice exercise on the current topic — generates short focused challenges adapted to learning type (code, conceptual, or scenario-based). Results saved to global education DB.

Use when the student wants a structured side-by-side comparison of two concepts — creates a researched comparison table, usage scenarios, misconceptions, and key takeaway adapted to the student's level

Use when the concept needs ANIMATION or INTERACTIVITY to be understood — step-by-step protocol flows, sorting algorithm traces, state machine transitions, network packet journeys, or anything where static images fall short. Generates a self-contained .html file with Canvas/SVG + JavaScript. Opens in any browser, zero dependencies. For static diagrams use /ascii (simple) or /excalidraw (complex).

Use when the student wants to generate Anki-style flashcards from studied topics — creates question/answer cards in Markdown and Anki-compatible CSV, prioritized by weak areas and misconceptions. Cards saved to global education DB and project-local docs.

Use when the student wants a visual learning roadmap for a goal or topic area — reads current knowledge state, researches the standard learning path, and generates an interactive .excalidraw diagram with color-coded topic nodes, prerequisite arrows, and milestone markers. Visual companion to /research.

Use when the user wants to be quizzed, tested, or asked questions on any topic — programming concepts, protocols, algorithms, tools, or any subject they are studying

Use when the student has a task, project, or goal and needs a structured learning plan — researches prerequisites, finds authoritative resources (docs, articles, RFCs, tutorials), and saves a checklist-style study plan to a file. The student follows the plan at their own pace.

DEFAULT diagram skill — simplest tier. Use when user invokes /ascii OR when suggesting a quick visual. Creates ASCII art rendered inline in terminal — zero friction. Escalate to /excalidraw for complex static diagrams (5+ components, multi-layer). Escalate to /demo for animated/dynamic concepts (protocol handshakes, algorithm traces, state transitions).