Claude Skills by siarhei-belavus

Orchestrate the full atelier workflow in one task window using pi teams runtime teams plus predefined agents, spawning right-side worker panes only when a phase is active and routing review loops until acceptance while preserving planner/implementer live context. Use when running discovery→plan→implement→review→distill as a lead agent from one orchestrator window, including initiative work that may hydrate child packets in owner repos.

Compare 2-3 materially different child-level contract/interface shapes and write the chosen direction into `CONTRACT_DECISION.md` before planning when local contract shape is ambiguous.

Compare 2-3 materially different initiative decompositions in `SPLIT_OPTIONS.md` when task boundaries or sequencing are still ambiguous before authoring `TASK_GRAPH.md`.

Curate durable residue from a completed task packet into canonical tracked `AGENTS.md` files or choose an explicit no-op.

Mine the current chat/history for forgotten durable-residue candidates and backfill `.plans/<task>/ARTIFACT_CANDIDATES.md` without touching tracked `AGENTS.md`. Use when implementation/debugging ran long, candidate capture was likely missed, or a human wants a manual mid-task history harvest.

Create a parent initiative packet under `.initiatives/<initiative-slug>/` with the canonical file tree, seeded shared-context docs, placeholder-owned files, and initial routing fields before split work begins.

Interview the user relentlessly about a plan or design until reaching shared understanding, resolving each branch of the decision tree one decision at a time. Use when a task is under-specified, a design needs stress-testing, or the user asks to be grilled.

Create an initiative child task packet in the selected child row's `Packet Root` at `.plans/<task-slug>/` with imported context, placeholder plan ownership, and packet-phase bootstrap metadata before planning begins.

Implement a planned task from `.plans/<task-slug>/` with strict plan adherence, explicit amendments, and no direct writes to tracked `AGENTS.md`.

Plan a development task into a self-sufficient execution contract stored in `.plans/<task-slug>/` for later fresh-context implementation and review.

Audit the tracked `AGENTS.md` tree against best practices, write `.agents/AGENTS_TREE_REVIEW.md`, and propose cleanup, compaction, conflict resolution, or sharding when needed. May auto-apply only trivial non-semantic hygiene fixes.

Review implementation for maintainability, evolvability, anti-slop, and human complexity; emit `M#` findings and durable residue candidates when needed.

Review implementation fidelity against `PLAN.md` and `AMENDMENTS.md`; emit `PS#` findings and validation-fact gaps into the task packet.

Blind-review `TASK_GRAPH.md` and optional `SPLIT_OPTIONS.md`, then write `SPLIT_REVIEW.md` with a ready/not_ready verdict before any child packets are hydrated.

Review `PLAN.md` as a blind-handoff execution contract; emit `P#` findings into the task packet and block plans with ambiguity, hidden assumptions, poor artifact hygiene, or missed durable-residue calls.

Turn a framed initiative into a reviewed child-task graph in `TASK_GRAPH.md`, using vertical slices, explicit dependencies, canonical child statuses, and reviewable child boundaries.

Populate `UBIQUITOUS_LANGUAGE.md` inside an initiative packet with canonical terms, aliases to avoid, flagged ambiguities, and term relationships before decomposition hardens.

Fold a child loop back into the parent initiative packet, update canonical parent truth, record the sync log, and route the next durable-distill timing decision.

Browser automation CLI for AI agents. Use when the user needs to interact with websites, including navigating pages, filling forms, clicking buttons, taking screenshots, extracting data, testing web apps, or automating any browser task. Triggers include requests to "open a website", "fill out a form", "click a button", "take a screenshot", "scrape data from a page", "test this web app", "login to a site", "automate browser actions", or any task requiring programmatic web interaction.

Implement development tasks in safe, reviewable increments. Use when the user wants code changes executed with clear sequencing, validation, maintainability guardrails, and alignment with later code review.

Explore a codebase to find opportunities for architectural improvement, focusing on making the codebase more testable by deepening shallow modules. Use when user wants to improve architecture, find refactoring opportunities, consolidate tightly-coupled modules, or make a codebase more AI-navigable.

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.

Triage a bug or issue by exploring the codebase to find root cause, then write an issue document in a local .issues folder with a TDD-based fix plan. Use when user reports a bug, wants to file an issue, mentions "triage", or wants to investigate and plan a fix for a problem.

Generate multiple radically different interface designs for a module using parallel sub-agents. Use when user wants to design an API, explore interface options, compare module shapes, or mentions "design it twice".

Automate Electron desktop apps (VS Code, Slack, Discord, Figma, Notion, Spotify, etc.) using agent-browser via Chrome DevTools Protocol. Use when the user needs to interact with an Electron app, automate a desktop app, connect to a running app, control a native app, or test an Electron application. Triggers include "automate Slack app", "control VS Code", "interact with Discord app", "test this Electron app", "connect to desktop app", or any task requiring automation of a native Electron appl...

Create focused GitLab merge requests with `glab`. Use when code changes are already implemented in a Git repository and Codex needs to inspect git state, isolate only the intended files, create or reuse a feature branch, run the repo's required validation commands, commit cleanly, push to `origin`, and open a merge request in GitLab.

Rebase the current branch with smart conflict resolution.

Search, create, and manage notes in the Obsidian vault with wikilinks and index notes. Use when user wants to find, create, or organize notes in Obsidian.

Extract a DDD-style ubiquitous language glossary from the current conversation, flagging ambiguities and proposing canonical terms. Saves to UBIQUITOUS_LANGUAGE.md. Use when user wants to define domain terms, build a glossary, harden terminology, create a ubiquitous language, or mentions "domain model" or "DDD".

Plan development tasks into clear, low-risk, reviewable increments. Use when the user wants an implementation plan, breakdown of a coding task, sequencing for a feature or refactor, migration planning, validation strategy, or a roadmap that stays maintainable and easy to review.

Interview the user relentlessly about a plan or design until reaching shared understanding, resolving each branch of the decision tree. Use when user wants to stress-test a plan, get grilled on their design, or mentions "grill me".

Break a PRD into independently grabbable implementation issues using tracer-bullet vertical slices, saved as local issue files alongside the PRD.

Turn a PRD into a multi-phase implementation plan using tracer-bullet vertical slices, saved as a local plan artifact alongside the PRD.

Create a detailed refactor plan with tiny commits via user interview, then save it as a local refactor RFC. Use when user wants to plan a refactor, create a refactoring RFC, or break a refactor into safe incremental steps.

Create a PRD through user interview, codebase exploration, and module design, then save it as a local artifact under a dedicated .prd folder.

Ultra-compressed code review comments. Cuts noise from PR feedback while preserving the actionable signal. Each comment is one line: location, problem, fix. Use when user says "review this PR", "code review", "review the diff", "/review", or invokes /caveman-review. Auto-triggers when reviewing pull requests.

Review code changes for correctness, regressions, edge cases, maintainability, and testing gaps. Use when the user asks for a review, asks whether an implementation is correct, wants a regression scan, wants a second pass after fixes, or wants findings-first feedback on a diff, patch, PR, commit, or uncommitted workspace changes.

Review a written plan for ambiguity, hidden assumptions, missing context, and handoff readiness. Use when the user provides a plan that must be clear, self-sufficient, standards-compliant, and safe to hand to another agent in a fresh context window with no extra explanation.

Manually spawn a one-off teammate after listing available models and proposing the best provider, model, and thinking level for the task. Use when manually invoked to create an ad hoc worker for focused implementation, research, review, or planning.

Explore a real site/feature with agent-browser, record per-scene screen clips + artifacts, then generate a CapCut-ready script grounded in the captured files. Includes retake workflow.

Turn a video brief into a CapCut-ready production script by asking up to 8 high-signal clarification questions (one at a time), then generating a scene-by-scene timeline with exact timings, track layout, and actionable editing steps.

Compress natural language memory files (AGENTS.md, todos, preferences) into caveman format to save input tokens. Preserves all technical substance, code, URLs, and structure. Compressed version overwrites the original file. Human-readable backup saved as FILE.original.md. Trigger: /caveman:compress <filepath> or "compress memory file"

Edit and improve articles by restructuring sections, improving clarity, and tightening prose. Use when user wants to edit, revise, or improve an article draft.

Create new agent skills with clear triggers, compact instructions, and optional bundled references or helper scripts. Use when user wants to create, write, design, refine, or package a reusable skill.