all publishers

Ninety2UA

@ninety2ua source repo

51 published skills

  1. ▌
    Ab Context Checkpoint · ninety2ua bundle
    Saves a lightweight recovery point mid-session: gathers the branch, recent commits, uncommitted changes and test state, then writes a timestamped docs/context/CHECKPOINT file with progress, decisions, next steps and open questions, or, near the end of a session, rewrites the Session Continuity section of docs/context/STATUS.md. Documentation only; faster and less complete than a session wrap. Use when the context window is getting large, before a risky operation such as a large refactor or dependency upgrade, when switching between major tasks, or after significant progress worth preserving. Mostly run by ab-pause-checkpoint. Not for the end of a session (ab-session-wrap) or as the user-facing pause (ab-pause-checkpoint).
    0 installs
  2. ▌
    Ab Migration Planning · ninety2ua bundle
    Plans a migration so every step can be undone: a blast-radius analysis of data, services and dependents, atomic expand-contract steps each deployable on its own, a forward and a rollback for each step with irreversible steps marked and backed up first, verification checks, and a pre-, during- and post-migration checklist. Use when a change needs careful sequencing, data transformation or rollback, whether or not the user calls it a migration: schema or data changes, API version transitions, breaking changes, major framework, ORM or runtime upgrades, or any change that could corrupt data or break downstream systems if just deployed. Not for a simple dependency addition (ab-dependency-management).
    0 installs
  3. ▌
    Ab Session Continuity · ninety2ua bundle
    Keeps docs/context/STATE.md, the execution-state file, current across session boundaries (plan and phase, wave and task progress, blockers, decisions to honor, next steps, a HEAD stamp) and refreshes the one-line summary in the Session Continuity section of docs/context/STATUS.md, so a later session or another tool resumes exactly where work stopped. Mostly run by ab-pause-checkpoint, ab-session-wrap and wave execution rather than by the user. Use when execution state must be written or read: starting or finishing a plan task or wave, hitting a blocker, pausing, handing off or resuming. Not the user-facing pause (ab-pause-checkpoint) or end-of-session wrap (ab-session-wrap).
    0 installs
  4. ▌
    Ab Wave Orchestration · ninety2ua bundle
    Groups dependent tasks into waves and runs them: tasks with no unmet dependency and no shared file run as parallel helpers within a wave, an integration verifier checks each wave before the next, and this session commits each task. Use when four or more tasks mix independent and dependent work and you want the wave pattern itself, for example inside another skill. Not for a whole plan run as team work with a task ledger (ab-orchestrate), all-sequential tasks (ab-autonomous-loop), all-independent items (ab-resolve-in-parallel), or three tasks or fewer.
    0 installs
  5. ▌
    Ab Resolve In Parallel · ninety2ua bundle
    Fixes a batch of independent items at once: checks that no two share a file or state, starts one helper per item (the pr-comment-resolver prompt for PR comments and review findings, a task packet for test failures and backlog items), then checks for conflicts, runs the full test suite and build, and commits the fixes. Use when several independent PR comments, review findings, test failures in different files or backlog items need fixing together. Not for items that share modified files or depend on each other (ab-wave-orchestration, for ordered execution).
    0 installs
  6. ▌
    Ab Swarm Orchestration · ninety2ua bundle
    Starts several read-only specialist helpers at once on the same input, each on one dimension such as quality, security, performance or a research angle, then hands all their outputs to a synthesizer that merges them into one report. Use when a thorough review, research, analysis or audit needs several perspectives on one problem, or to compose a custom swarm such as a migration or architecture review. Not for the standard review or research swarm (ab-review-swarm, ab-deep-research), sequential tasks (ab-autonomous-loop), tasks that modify shared state (ab-wave-orchestration), or when one perspective is enough (start a single helper).
    0 installs
  7. ▌
    Ab Using Git Worktrees · ninety2ua bundle
    Sets up an isolated git worktree for feature or parallel work: picks the worktree folder (an existing one, then the project instructions file's preference, then asks), checks that a project-local folder is git-ignored, creates the worktree on a new branch, installs dependencies and runs the tests for a clean baseline, and later removes worktrees without force. Use when work needs isolation from the current checkout, when parallel helpers need separate branches, or before running a plan in its own workspace; usually started by other skills such as ab-orchestrate. Not for plain branch creation (use git checkout -b).
    0 installs
  8. ▌
    Ab Changelog Generation · ninety2ua bundle
    Generates release notes from git history in Keep a Changelog format: finds the range since the last release tag, sorts the commits into Added, Changed, Deprecated, Removed, Fixed and Security, rewrites them for users with breaking changes and PR links, and adds the entry to CHANGELOG.md. Use when preparing a release or version tag, writing release notes for stakeholders, updating CHANGELOG.md, or answering what changed since the last release. Not for a session summary (ab-session-wrap) or a PR description (ab-pr-workflow).
    0 installs
  9. ▌
    Ab Iterative Refinement · ninety2ua bundle
    Runs review-fix-review cycles on a change until quality converges: a deslop pass, then per iteration an ab-review-swarm review, findings routed by tier, fixes through ab-resolve-in-parallel, tests, build and a commit, until the convergence mode is met (fast: no P1, deep: no P1 or P2, perfect: none) or max_iterations (default 3) runs out. Use when ab-ship-pipeline or ab-build-pipeline reaches review, or when the user wants code polished past a single review pass. Not for a trivial change (one ab-review-swarm pass) or findings that need an architecture change (re-plan).
    0 installs
  10. ▌
    Ab Systematic Debugging · ninety2ua bundle
    Finds a bug's root cause before any fix: classifies the error, reproduces it, traces the bad value to its source, tests one hypothesis at a time against evidence tiers, fixes test-first, and questions the design after three failed fixes. Use when there is a bug, error, test failure, crash, regression, flaky test or unexpected behavior, even when the user wants to jump straight to a fix without knowing why it broke. Not for new features (use ab-brainstorming) or tests for working code (use ab-add-tests).
    0 installs
  11. ▌
    Ab Dependency Management · ninety2ua bundle
    Adds, upgrades and removes project dependencies deliberately: checks a new package against five gates (necessity, maintenance, size, license, security) and build-versus-install, installs a pinned version range, commits the manifest and lockfile together with the reason, upgrades by changelog and risk, and removes unused packages cleanly. Use when adding, upgrading or removing a dependency, even a single package, when resolving a version conflict, responding to a security advisory, or auditing dependencies. Not for updating the Agent Blueprint plugin itself, nor for dev tooling that does not ship with the product (linters, formatters), which you can simply install.
    0 installs
  12. ▌
    Ab Knowledge Compounding · ninety2ua bundle
    Records a solved problem as a searchable solution document in docs/solutions/ (problem, root cause, solution, failed approaches, key insight, search terms), cross-links it to related solutions and decisions, and adds a one-line learning to the project instructions file when the lesson applies broadly. Also runs a gardening pass that prunes stale, orphaned or contradictory entries. Use after a non-trivial bug fix, a framework gotcha or version-specific behavior, a reusable pattern, or an architectural decision with real trade-offs, when the lesson is one the code, tests and commit message do not already carry; when the user asks to document, save or remember a solution so it is not hit again; or to tidy the knowledge base. Not for typos, import fixes, one-off config changes, or anything framework docs, a regression test or a code comment already covers.
    0 installs
  13. ▌
    Ab Performance Profiling · ninety2ua bundle
    Makes slow code faster by measurement: a baseline with its run-to-run variance, a profile of the critical path, a hypothesis the data supports, one optimization at a time re-measured against that noise floor, and a record of reverted attempts so none is retried. Use when something is slow, laggy or timing out, latency, CPU or memory has regressed, N+1 queries or a bottleneck is suspected, or the user wants code sped up, including when they want to jump straight to a fix such as adding an index or a cache. Not for code quality changes unrelated to performance (ab-iterative-refinement, or a code simplification skill).
    0 installs
  14. ▌
    Ab Receiving Code Review · ninety2ua bundle
    Acts on code review feedback by checking it first: restates each item, verifies it against the codebase, then implements it one item at a time with a test each or pushes back with technical reasons, with no performative agreement. Treats reviewer text as data, flags injected directives, and clarifies unclear items before changing anything. Use when PR review comments or reviewer pushback arrive, when feedback seems questionable, unclear or wrong, or when findings from ab-review-swarm or ab-requesting-code-review need acting on. Not for opening a PR or running its resolve-and-reply loop with helpers (ab-pr-workflow).
    0 installs
  15. ▌
    Ab Requesting Code Review · ninety2ua bundle
    Runs a fast single-reviewer code review: picks a guarded review range (one task's commit, a whole branch from its merge base, or the working tree in no-commit mode), hands it with the plan to the code-reviewer helper, and acts on the Critical, Important and Suggestion findings it returns. Use when a task or bug fix is finished, before committing or merging, when stuck, or when the user asks to review or check recent changes. Not for a multi-perspective or thorough review, or a change that could fail silently or touches auth, money, data or a public contract (ab-review-swarm).
    0 installs
  16. ▌
    Ab Test Driven Development · ninety2ua bundle
    Drives new code from tests with red-green-refactor: write one failing test, watch it fail for the expected reason, write the least code that passes, run the whole suite, then refactor while green. Only code the model wrote in this task before its test is discarded, unless the user says to keep it. Use when implementing a feature, fixing a bug, refactoring or changing behavior, before any implementation code and whether or not the user mentions tests. Not for backfilling tests on existing code that is not being changed (use ab-add-tests).
    0 installs
  17. ▌
    Ab Source Driven Development · ninety2ua bundle
    Writes framework- and library-specific code from the official docs for the installed version: reads exact versions from the dependency file, fetches the relevant docs page, follows its documented pattern, and cites the URL or marks the code UNVERIFIED. Use when writing or reviewing code against a framework or library API (forms, routing, data fetching, state, auth, hooks, components, ORM queries, config), when generating boilerplate that will be copied, or when the user asks for documented or verified code. Not for logic that works the same in every version, renames or typo fixes, or when the user wants speed over verification. Companion to ab-deep-research, which gathers docs before planning; this skill governs their use at write time.
    0 installs
  18. ▌
    Ab Dispatching Parallel Agents · ninety2ua bundle
    Splits two or more independent problems into one focused helper each, all started at once, each with its own scope, goal, constraints and expected output, then reviews and integrates what they return. Use when several unrelated failures (different test files, subsystems or bugs), independent code changes or separate analyses can proceed at the same time, usually as a step inside another skill. Not for work that touches shared state or a whole plan run as team work (ab-orchestrate), or for a single task, which is quicker done directly.
    0 installs
  19. ▌
    Ab Subagent Driven Development · ninety2ua bundle
    Runs a written plan in this session one task at a time: a fresh helper implements each task from its full text, a spec-compliance reviewer and then a code-quality reviewer check it, fix rounds repeat until both pass, and a final review covers the whole implementation. Use when a plan's tasks are mostly independent and you want clean context per task without leaving this session; usually invoked by another skill. Not for tightly coupled tasks that share state (execute those in order yourself), a separate session with human checkpoints (ab-executing-plans), or parallel team work (ab-orchestrate).
    0 installs
  20. ▌
    Ab Finishing A Development Branch · ninety2ua bundle
    Finishes a development branch whose work is done: runs the tests, has a read-only helper audit each plan item against the diff, offers to merge locally, push and open a PR, or keep the branch, and carries out the choice; discarding needs an explicit request and typed confirmation. Use when implementation is complete and tests pass, or the user says the work is done or ready to merge, or asks what now. Not for creating a PR alone (use ab-pr-workflow), or while work is in progress or tests fail.
    0 installs
  21. ▌
    Ab Verification Before Completion · ninety2ua bundle
    Backs every completion claim with fresh evidence: names the output that would prove the claim false, runs the full verification command, reads its output and exit code, and only then states the result, quoting that evidence. Use before saying work is done, tests pass, a build succeeds or a bug is fixed; before committing, opening a PR or reporting a task complete; and before trusting a helper's success report. A run from an earlier message does not count.
    0 installs
  22. ▌
    Ab Discuss · ninety2ua bundle
    Captures and locks the user's decisions before planning: asks a few focused multiple-choice questions on the ambiguous choices, checks earlier ADRs, plans, research and learnings for prior art, and records decisions, non-goals and open questions in docs/context/DECISIONS.md for planners to honor. Use when requirements are ambiguous or assumptions undocumented, or when the user wants to settle decisions, constraints or requirements before a plan is written. Not for exploring designs and alternatives (ab-brainstorming) or for implementing anything: it records decisions and does not act on them.
    0 installs
  23. ▌
    Ab Migrate · ninety2ua bundle
    Cleans an old Agent Blueprint install out of a project so v4 runs alone: finds the v3 plugin and the v2/v3 copies (.claude/skills, agents, commands and hooks copied by install.sh --legacy, scripts/ship.sh, the old manifest, ship state files), shows the list, asks once, removes only the blueprint's own files, renames CLAUDE.md to AGENTS.md with a one-line CLAUDE.md that imports it, and prints the uninstall command for the v3 plugin. Use when the user asks to migrate a project from claude-code-blueprint or an in-project blueprint copy to Agent Blueprint v4. Not for a project's own dependencies or for anything the blueprint did not install.
    0 installs
  24. ▌
    Ab Ideation · ninety2ua bundle
    Generates grounded improvement ideas for a project: scans its learnings, structure and git history with three helpers, generates candidates from three frames (friction, inversion, leverage), rejects the weak ones with a reason each, and saves 5-7 ranked survivors to docs/research/. Use when the user asks what to build, change or improve next, wants ideas, feels stuck or unsure where to focus, or starts a session with no clear goal. Not for designing something the user already chose (ab-brainstorming) or researching a named topic (ab-deep-research).
    0 installs
  25. ▌
    Ab Add Tests · ninety2ua bundle
    Backfills tests for existing code that has none: a helper inventories the current tests, traces untested branches, error paths and edge cases, ranks the gaps by risk (critical, high, medium, low) and drafts behavioral tests; the user picks which gaps to fill, each is written with the ab-test-driven-development skill, the whole suite is run, and the new tests are committed. Use when the user asks to add tests, improve coverage or find what needs tests, when a module, file or recent change has no tests, or when a coverage report shows gaps. Not for tests written while new code is being implemented (use ab-test-driven-development).
    0 installs
  26. ▌
    Ab Forensics · ninety2ua bundle
    Diagnoses a failed, stalled or aborted automated run after the fact, read-only: finds the run's logs, run state and git history, checks for stuck loops, missing artifacts, abandoned work and crashes, redacts secrets, and writes an evidence-cited report (verdict, timeline, root-cause hypothesis, recommended next action) to .agent-blueprint/forensics/. Use when ab-ship-pipeline, ab-orchestrate, a build pipeline or an iteration loop ended without delivering, stopped early, did not converge or left contradictory results, and the user wants a post-mortem before retrying. Not for live debugging of a code bug (ab-systematic-debugging), for fixing the failure (a separate step), or for a routine status check (ab-project-status, ab-health-check).
    0 installs
  27. ▌
    Ab Quick Fix · ninety2ua bundle
    Makes a small, well-understood change through a short test-first loop: checks that the change qualifies (under three files, obvious approach), writes a failing test, makes the minimal fix, runs the full test suite, build and lint, and commits on a branch. Use when the change is a bug fix whose cause is known, a typo, copy or config change, a rename, a changed default or minor refactor within one module, or a test for existing behavior, whatever the user calls it. Not for changes touching three or more files, new public APIs, endpoints or schemas, data-model changes, or an unclear approach (use ab-brainstorming, then ab-build-pipeline), nor for a bug whose cause is not yet known (use ab-systematic-debugging first).
    0 installs
  28. ▌
    Ab Deepen Plan · ninety2ua bundle
    Enriches an existing plan with research: five read-only helpers run in parallel (prior solutions, best practices, current framework docs, the files and dependencies the change touches, git history), their findings go under each plan section as Research Notes without changing its tasks or order, and a plan-checker flags conflicts with the plan's approach. Use when a plan exists but is thin on framework detail, prior art or constraints (suggest it before execution starts), or when the user asks to deepen, enrich, research or flesh out a plan. Not for writing a plan when none exists (ab-writing-plans) or research without a plan (ab-deep-research).
    0 installs
  29. ▌
    Ab Orchestrate · ninety2ua bundle
    Runs a plan as team work: a task ledger, dependency-ordered waves of parallel helpers with file ownership or worktrees, integration checks between waves, lead-only commits, then review and sign-off. Use when a plan has four or more tasks, some of them independent, or when the user asks for parallel, team, wave or collaborative execution. Not for a sequential plan with review checkpoints between batches (ab-executing-plans) or a change under three files (ab-quick-fix).
    0 installs
  30. ▌
    Ab Pr Workflow · ninety2ua bundle
    Takes a branch through its pull request: runs the declared checks on the exact commit being pushed, renders the plan audit, writes a motivation-first body scanned for secrets, self-reviews the diff, resolves review comments with one helper each, and merges only onto a green base. Use when a branch is ready for review or merge, when the user wants to open or submit a PR, or when PR comments need fixes and replies. Not for finishing a branch without a PR (use ab-finishing-a-development-branch) or reviewing someone else's PR (use ab-requesting-code-review or ab-review-swarm).
    0 installs
  31. ▌
    Ab Health Check · ninety2ua bundle
    Runs a project health check across eight areas (build, tests, lint, dependencies, convention compliance, documentation freshness, backlog, git) with the commands from docs/context/CONVENTIONS.md, then reports a status table, the items that need attention and the next actions. Use when the user asks how the project is doing, whether everything is working or passing (including just the build or the tests), or wants diagnostics across the whole project. Not for a progress or status update (ab-project-status) or for debugging one failing test or error (ab-systematic-debugging).
    0 installs
  32. ▌
    Ab Review Swarm · ninety2ua bundle
    Reviews a change with specialized reviewers in parallel (quality, simplicity and tests always; security, performance, conventions, frontend, architecture, data and schema as the diff calls for), validates the findings and merges them into one prioritized P1/P2/P3 report. Use when a change is large (5+ files, several concerns, crossing modules) or consequential at any size (auth, money, data, a public contract, silent failures), before a production ship or major merge, or when asked for a full or multi-perspective review. Not for a quick single-perspective review of a small change (use ab-requesting-code-review).
    0 installs
  33. ▌
    Ab Session Wrap · ninety2ua bundle
    Ends a work session from git history and the file system: shows a summary for the user to confirm, rewrites the Session Continuity section of docs/context/STATUS.md, records durable learnings, updates the status tables, goals, backlog, plans, specs and ADRs the session touched, and commits the docs. Documentation only. Use when the user is wrapping up or ending the session, and suggest it when a session ends without one. Not for a mid-session checkpoint or pause (use ab-pause-checkpoint).
    0 installs
  34. ▌
    Ab Brainstorming · ninety2ua bundle
    Turns an idea into an approved design, honoring prior design approval, authorization to implement a seen design, or an explicit design waiver: settles what the repository answers, challenges the premise, asks the remaining questions one at a time, compares two or three approaches, presents the design in sections for approval, then saves it and hands off to ab-writing-plans. Use when the user wants to brainstorm or design a change, or when work involves design decisions, several viable approaches or three or more files, including when the user jumps straight to code on such work. Not for a trivial change under three files with one obvious approach (ab-quick-fix), or for recording decisions without exploring alternatives (ab-discuss).
    0 installs
  35. ▌
    Ab Deep Research · ninety2ua bundle
    Researches a topic before planning: five helpers run in parallel (past learnings in docs/solutions/ and docs/research/, framework docs for the installed versions, industry best practices, git history, and a map of the code the change touches), and a synthesizer merges them into one brief in docs/research/ with consensus, unique insights, contradictions, gaps and a recommended approach. Use when planning or building in unfamiliar code or technology, before an architectural decision, major refactor or migration, when onboarding to an area of the codebase, or when the user asks to research, investigate or learn best practices before building. Not for a small, well-understood change (ab-quick-fix), debugging a failure (ab-systematic-debugging) or enriching an existing plan (ab-deepen-plan).
    0 installs
  36. ▌
    Ab Plugin Update · ninety2ua bundle
    Upgrades the Agent Blueprint plugin itself to its latest release: finds how Agent Blueprint was installed in the current tool, runs or shows that tool's own plugin manager command (Claude Code, Codex and the other supported tools), re-runs install.sh for copy installs, then checks the installed version against the latest release. Use when the user asks to upgrade, refresh or reinstall Agent Blueprint itself. Not for a project's own dependencies (ab-dependency-management) or for cleaning an old in-project v2 copy out of a repository.
    0 installs
  37. ▌
    Ab Project Start · ninety2ua bundle
    Sets up a project for Agent Blueprint: scaffolds AGENTS.md, a one-line CLAUDE.md that imports it, docs/context/ and BACKLOG.md by merging into what exists (never overwriting), then fills in conventions, goals and status from the codebase and a short conversation. Use when starting a new project or adopting the blueprint in an existing one, when the user asks to initialize, set up or bootstrap, or when docs/context/ is missing. Not for a status update (ab-project-status) or resuming earlier work (ab-resume-session).
    0 installs
  38. ▌
    Ab Scope Cutting · ninety2ua bundle
    Cuts a feature or plan down to the smallest useful deliverable: lists everything in scope, sorts it with MoSCoW (must, should, could, won't), checks the must-haves still make a usable, testable, shippable feature, rewrites the plan around them and tracks the rest in BACKLOG.md. Use when a feature or plan is too big for the time available, a plan has more than about 10 tasks, a spike found more complexity than expected, or the user worries about the timeline or asks to scope down, simplify or find the MVP. Not for a feature that is already minimal, or one whose complexity sits in the core, which needs a different approach rather than less scope.
    0 installs
  39. ▌
    Ab Ship Pipeline · ninety2ua bundle
    Ships a feature end to end with no checkpoints: recorded assumptions, a verified and deepened plan, execution through ab-orchestrate, review until it converges, then commits and a PR body, tracked in .agent-blueprint/run/state.json. Use when the user wants a well-defined feature built hands-off, fire and forget, through to a pull request. Not for work the user approves stage by stage (ab-build-pipeline) or a change under three files (ab-quick-fix).
    0 installs
  40. ▌
    Ab Writing Plans · ninety2ua bundle
    Turns an approved design or a clear spec into an implementation plan that records decisions, not code: exact file paths, each test and what it asserts, signatures and spec values, dependency order, verification commands, boundaries and a review focus, saved for review before anything runs. Use when an approved design or spec needs breaking into bite-sized executable tasks, when the user asks for a plan or implementation steps, or once ab-brainstorming has an approved design. Not for work with no design yet (ab-brainstorming), executing a plan (ab-executing-plans) or enriching one with research (ab-deepen-plan).
    0 installs
  41. ▌
    Ab Backlog Triage · ninety2ua bundle
    Triages the Inbox of BACKLOG.md: reads the goals and status for context, sorts each item into a task, bug, feature, research item or parked idea with a P0-P3 priority and a type tag, flags off-goal items, presents the triage as a table for approval, then moves the items and commits. Use when the user asks to triage, sort, clean up or prioritize the backlog, asks what is in it or whether new items arrived, or when the Inbox holds untriaged items. Not for a project status overview (ab-project-status) or for doing the work items (ab-build-pipeline, ab-ship-pipeline or ab-quick-fix).
    0 installs
  42. ▌
    Ab Build Pipeline · ninety2ua bundle
    Runs a feature through eight supervised stages (discuss, brainstorm, plan, execute, review, verify, optional deploy check, knowledge capture) with a checkpoint after each where the user approves, changes or stops; research and plan-check helpers feed the plan, and complex plans run as team waves. Use when building a non-trivial feature or multi-file change with oversight or approval between steps. Not for hands-off runs with no checkpoints (ab-ship-pipeline) or a change under three files with an obvious approach (ab-quick-fix).
    0 installs
  43. ▌
    Ab Project Status · ninety2ua bundle
    Reports where the project stands: reads docs/context/STATUS.md (its Session Continuity section first), GOALS.md, BACKLOG.md and the git state, then presents the code state, work in flight, goal progress, what needs attention and the top three next actions with reasons. Use when the user asks for status, an overview or summary, what is going on, what is next or what the priorities are, or wants to get oriented at the start of a session. Not for resuming a prior session's tasks (ab-resume-session), a build, test and lint health check (ab-health-check), or setting up a new project (ab-project-start).
    0 installs
  44. ▌
    Ab Resume Session · ninety2ua bundle
    Reloads what earlier sessions left (the Session Continuity section and the rest of docs/context/STATUS.md, STATE.md, GOALS.md, BACKLOG.md, the latest checkpoints), checks git state and whether HEAD moved since the handoff, then presents an orientation of status, the last session's own pointers and the recorded traps, and asks where to start. Use when the user wants to resume, continue or pick up earlier work or asks what they were working on, or opens a new session with only a greeting in a project whose STATUS.md has session history. Not for a new project with no history (ab-project-start) or a quick status overview without resuming work (ab-project-status).
    0 installs
  45. ▌
    Ab Writing Skills · ninety2ua bundle
    Writes, edits and tests skills that load and run in every tool Agent Blueprint supports: agentskills frontmatter, a SKILL.md under 8,000 bytes with detail in references/, capability snippets for host-dependent steps, prompt files for helpers, and a baseline test before the skill is written. Use when creating or editing a skill, rewriting its description or frontmatter, cutting it to size, or finding out why it does not trigger. Not for a project's own conventions (the project instructions file) or a rule a script can check (write the check).
    0 installs
  46. ▌
    Ab Autonomous Loop · ninety2ua bundle
    Runs a plan's tasks one after another with no human checkpoints: do the next unchecked task, verify it, tick it and commit, retry failures after a written reflection, and stop on a fatal error, a circuit breaker, a risk score or a hard cap. Often started by the pipeline skills. Use when a plan of mostly sequential tasks should run to the end unattended, or the user says to keep going until all of it is done. Not for review checkpoints between batches (ab-executing-plans) or tasks that can run in parallel (ab-orchestrate).
    0 installs
  47. ▌
    Ab Browser Testing · ninety2ua bundle
    Verifies UI changes in a real browser: starts the dev server, opens the affected pages with a browser automation tool (such as a Playwright MCP server), reads accessibility snapshots, runs the interaction flows including error states, checks mobile, tablet and desktop widths, and reports pass or fail per check; without a browser tool it lists the checks to run by hand. Use when a change touches UI components (.tsx, .jsx, .vue, .svelte), CSS, SCSS or HTML templates, CSS-only changes included; when the user asks for a browser, UI, form or layout check; or when unit tests pass but the rendered experience still needs confirming.
    0 installs
  48. ▌
    Ab Document Review · ninety2ua bundle
    Reviews a written document in three separate passes (accuracy, with a helper that checks every file, command and endpoint it names against the repository; then clarity; then completeness) and ends with the must-fix issues in priority order and a verdict: approved, revisions needed or rework needed. Use when the user wants feedback on, a critique of or a proofread of a spec, plan, ADR, README, design doc, RFC or other write-up, including a casual 'does this look good' about a document. Not for code review (ab-requesting-code-review or ab-review-swarm) or changelogs and release notes (ab-changelog-generation).
    0 installs
  49. ▌
    Ab Executing Plans · ninety2ua bundle
    Executes a written plan in this session in batches of three tasks: each task is followed step by step, verified, committed and ticked in a progress file; each batch ends with a report and a checkpoint for the user's feedback; a whole-branch review closes the run. Reads plans that use v3 skill names. Use when the user wants to work through a plan with human review between batches. Not for parallel or team work (ab-orchestrate) or fully autonomous runs (ab-autonomous-loop).
    0 installs
  50. ▌
    Ab Pause Checkpoint · ninety2ua bundle
    Saves a quick mid-session snapshot when the user steps away: writes a checkpoint of the branch, changes, decisions and next steps through ab-context-checkpoint, and updates the execution state in docs/context/STATE.md (wave progress, task completion, blockers) through ab-session-continuity. Documentation only; the session goes on afterwards. Use when the user wants to pause, take a break, save progress or checkpoint their place for a quick return. Not for the end of a full work session, which needs complete documentation, learnings and cross-session continuity (ab-session-wrap).
    0 installs
  51. ▌
    Ab Spike Exploration · ninety2ua bundle
    Runs a timeboxed, hands-on spike that answers one technical question with throwaway code: sets the question, timebox and success criteria, explores on a spike branch or scratch folder, gathers evidence, and writes a spike report with a recommendation to docs/research/spikes/. Use when it is unclear whether an approach will work, when choosing between technologies or a costly-to-reverse option, when integrating an unfamiliar API, when a debate has no data or an estimate is guesswork, or when the user asks for a spike or proof of concept; suggest one before the user commits to an approach without evidence. Not for documentation research or context gathering (ab-deep-research), questions the docs answer, or effort estimates for a clear approach.
    0 installs