← all publishers

ayoubben18

@ayoubben18 source repo

26 published skills

  1. Ab Mastermind · ayoubben18
    The intelligent entry point to the AB Method. Use when the user isn't sure which workflow they need, asks whether to create a goal or a task, or wants to understand how the AB Method works end to end. Routes intent to the right workflow instead of reimplementing it.
    0 installs
  2. Ab Start Task · ayoubben18
    Run an existing task autonomously to completion — each remaining mission in a subagent with tdd, tracker updated per mission, a commit after every green mission. Use when the user wants to hand off a well-defined task and review commits instead of missions.
    0 installs
  3. Ab Create Goal · ayoubben18
    Produce a ready-to-run prompt for an autonomous /goal loop. Use when the user wants to hand off one continuous objective with a verifiable stop condition to run autonomously.
    0 installs
  4. Ab Create Task · ayoubben18
    Create a focused task and break it into test-driven missions. Use when the user wants to start a new feature, fix a bug, or begin implementation work.
    0 installs
  5. Ab Extend Goal · ayoubben18
    Extend an existing goal — broaden or add to its objective, building on top of what the earlier /goal run already implemented. Use when the user wants to expand a goal after a /goal run.
    0 installs
  6. Ab Extend Task · ayoubben18
    Append new missions to an existing task. Use when requirements changed or scope grew on a task already underway.
    0 installs
  7. Ab Resume Task · ayoubben18
    Continue an existing task from its progress tracker. Use when the user wants to resume, continue, or pick up earlier task work.
    0 installs
  8. Ab Test Mission · ayoubben18
    Add retroactive test coverage for code that was not written test-first. Use when the user wants to backfill tests.
    0 installs
  9. Ab Start Roadmap · ayoubben18
    Execute a roadmap autonomously to completion — the layer above start-task. Use when a roadmap's tasks are planned and you want them run in dependency order, with independent tasks optionally in parallel. Verifies the dependency tree is planned before running; stops if a needed task has no plan. Executor only.
    0 installs
  10. Ab Create Roadmap · ayoubben18
    Turn a larger idea into a dependency-ordered roadmap of tasks — the layer above create-task. Use when the work is several distinct tasks with real ordering between them (schema before API before UI), and you want the whole task graph drawn before implementing. Producer only; ab-start-roadmap executes it.
    0 installs
  11. Ab Analyze Backend · ayoubben18
    Analyze and document a project's backend patterns — API design, data access, service structure. Use when the user wants a backend-only architecture analysis.
    0 installs
  12. Ab Analyze Project · ayoubben18
    Analyze a project's architecture end to end — extract domain language, map the tech stack, document frontend and backend patterns. Use when onboarding a new codebase or refreshing the architecture baseline.
    0 installs
  13. Ab Analyze Frontend · ayoubben18
    Analyze and document a project's frontend patterns — component structure, state management, conventions. Use when the user wants a frontend-only architecture analysis.
    0 installs
  14. Ab Update Architecture · ayoubben18
    Refresh architecture and domain documentation after impactful changes. Use when code has drifted from the documented architecture.
    0 installs
  15. Ab Create Task From Handoff · ayoubben18
    Resume a handoff (a side-topic spun off mid-grill) and turn it into a test-driven task. Use when the user wants to continue grilling on a deferred topic captured under docs/handoffs/.
    0 installs
  16. Tdd · ayoubben18 bundle
    Test-driven development with red-green-refactor loop. Use when user wants to build features or fix bugs using TDD, mentions "red-green-refactor", wants integration tests, or asks for test-first development.
    1 install
  17. Handoff · ayoubben18
    Compact the current conversation (or a side-topic that surfaced mid-grill) into a handoff document another agent can pick up. Use when a tangent deserves its own task, or to summarize a session for a fresh agent.
    1 install
  18. Change Map · ayoubben18 bundle
    Draw a task's blast radius twice. BEFORE implementing, a PLANNED map of the modules the missions expect to add, change or touch; AFTER the reviewers pass, an ACTUAL map derived from the real diff, plus the DRIFT between them. Writes docs/tasks/<task>/change-map.md. Use from create-task / extend-task (planned pass), and after review-implementation + sync-architecture in create-task / resume-task / start-task / start-roadmap (actual pass), or standalone on a task.
    1 install
  19. Domain Model · ayoubben18 bundle
    Grilling session that challenges your plan against the existing domain model, sharpens terminology, and updates documentation (CONTEXT.md, ADRs) inline as decisions crystallise. Use when user wants to stress-test a plan against their project's language and documented decisions.
    1 install
  20. Critique Plan · ayoubben18
    Pre-implementation critic. Spins up a read-only domain critic that challenges a drafted plan — a task's missions or a roadmap's task graph — against the ubiquitous language, CONTEXT.md, and ADRs, and pushes back ONLY on genuine conflicts. Silent when the plan is sound. Use before implementing (from create-task / create-roadmap) or standalone to stress-test a plan against the project's domain model.
    1 install
  21. Codebase Design · ayoubben18 bundle
    Shared vocabulary and principles for designing deep modules — small interfaces, clean seams, testable through the interface. Use when designing or improving a module's interface, deciding where a seam goes, hunting deepening opportunities, making code more testable, or when another skill needs the deep-module vocabulary.
    1 install
  22. Grill With Docs · ayoubben18 bundle
    Grilling session that challenges your plan against the existing domain model, sharpens terminology, and updates documentation (CONTEXT.md, ADRs) inline as decisions crystallise. Parks the rare question you genuinely can't answer yet as an unresolved question with a placeholder, so the build proceeds instead of stalling. Use when user wants to stress-test a plan against their project's language and documented decisions.
    1 install
  23. Reconcile Roadmap · ayoubben18
    Cross-plan coherence critic for a whole roadmap. Reads roadmap.md plus every planned task's progress-tracker.md and pushes back ONLY on genuine discrepancies BETWEEN the finished plans — broken seams, coverage gaps, duplicated work, reversed/missing edges, terminology drift, conflicting assumptions. Read-only; silent when the plans cohere. Run standalone after planning finishes and before /start-roadmap.
    1 install
  24. Sync Architecture · ayoubben18
    Post-implementation documentation-sync detector. Spins up ONE read-only subagent on a completed task's diff to find everything the change introduced that the architecture docs don't yet know about — new endpoints, patterns, dependencies, domain terms, ADR-worthy decisions — routed to the exact doc each belongs in. Autonomous runs apply only append-only safe additions and defer domain/ADR reshapes; interactive runs present the proposed doc deltas to pick. Use after a task's missions are done (from create-task / start-task / start-roadmap) or standalone on a diff.
    1 install
  25. Review Implementation · ayoubben18 bundle
    Post-implementation review. Spins up three read-only critics on a completed task's diff — cleaner-architecture, slop-defender, reusability-inspector — that push back ONLY on real issues. Autonomous runs apply safe fixes (tests-green-gated) and write everything to review.md next to progress-tracker.md; interactive runs present findings to pick. Use after a task's missions are done (from start-task / start-roadmap / create-task) or standalone on a diff.
    1 install
  26. Improve Codebase Architecture · ayoubben18 bundle
    Scan a codebase for deepening opportunities, present them as a visual HTML report, then grill through whichever one you pick. Informed by the domain language in CONTEXT.md and the decisions in docs/adr/. Use when the user wants to improve architecture, find refactoring opportunities, consolidate tightly-coupled modules, or make a codebase more testable and AI-navigable.
    1 install