darbin

@darbin source repo

19 skills
0 followers
11 hours ago last updated

▌
Rem Loop · darbin bundle
Autonomous agentic loop patterns for multi-iteration work — PR Loop (branch → implement → CI → auto-fix → repeat with SHARED_TASK_NOTES.md context bridge) and De-Sloppify (two-pass - implementation agent then dedicated cleanup agent). Use when a task requires many iterations against CI feedback, when you want a post-implementation cleanup pass without negative constraints, or when you need to bridge context between loop iterations. Distinct from the built-in /loop (which schedules recurring prompts on an interval) — rem-loop provides the PATTERNS for building autonomous development loops. Use for "autonomous loop", "keep running until CI passes", "pr loop", "loop until green", "agentic loop", "cleanup pass", "de-sloppify", "two-agent pattern", "context bridge", "SHARED_TASK_NOTES".

0
installs
▌
Rem QA · darbin bundle
Visual QA testing across real browser — Playwright (primary) or Chrome DevTools MCP (fallback). QA this, QA the site, test the site, check for visual bugs, run QA, browser test, visual test, smoke test, screenshot test, cross-page testing, mobile testing, desktop testing, diff-aware QA, Playwright testing, Lighthouse audit, health score, visual regression, find broken layouts, find dead clicks, find console errors. Crawls multiple pages, tests interactions at mobile + desktop viewports, captures screenshots to `tmp-screenshots/`, monitors console errors + network failures, detects layout shift (CLS) + touch-target violations + horizontal overflow, runs Lighthouse, produces 8-dimension health score (Visual / Interactivity / Mobile UX / Performance / Error-Free / Accessibility / Consistency / Content). Diff-aware mode (`/rem-qa diff`) tests only pages affected by recent git changes. Convention-aware — reads CLAUDE.md so it doesn't flag intentional z-index / overlay / mobile-nav patterns. Distinct from rem-revie

0
installs
▌
Rem Learn · darbin bundle
Extract permanent lessons from the current session so they're never repeated. Mines git diff / reflog / conversation for error→fix chains, silent failures (code ran but produced wrong data), near-misses (almost deployed X), wasted effort (spent 30m on wrong approach), positive patterns worth replicating, and architecture insights uncovered during debugging. Writes grep-able entries to learnings.md / auto-memory / CLAUDE.md with code, exact error messages, dates, keywords — NOT "be more careful with types". Escalates 3+ similar entries to project CLAUDE.md conventions, universal lessons to global `~/.claude/CLAUDE.md`. Prunes stale entries, keeps MEMORY.md under 200 lines. Distinct from rem-handoff (which saves session-resumption state, not lessons). Use for "learn from this", "remember this", "update learnings", "never do this again", "capture lessons", "save what we learned", or after any debugging / error session.

0
installs
▌
Rem Skill · darbin bundle
Build, evaluate, improve, and analyze Claude Code skills. Encodes skill-design expertise — description optimization, progressive disclosure via `_references/`, knowledge-delta scoring, archetype selection, anti-pattern detection. ANALYZE mode reads `~/.claude/skill-feedback.jsonl` (populated by `/rem-feedback`), aggregates by skill + mistake_type, and proposes targeted edits — description triggers for misrouted flags, new anti-patterns for missed, severity calibration for over-flagged, Step-0-context for context-ignored, freshness stamps for stale. IMPROVE mode consumes that analysis and applies edits, marking entries `addressed`. Use when the user says "create skill", "new skill", "evaluate skill", "audit skill", "improve skill", "refactor skill", "skill builder", "meta-skill", "analyze skill", "aggregate feedback", "why is rem-X misfiring", "skill report card", "skill health", "skill won't load", "skill not triggering", "skill not firing", "diagnose skill", "skill doctor", "why isn't my skill loading".

0
installs
▌
Rem Solve · darbin bundle
Interactive problem-solving wizard. Guides through structured Q&A using interactive popups, codebase analysis, web research, and multi-approach comparison to find the best solution. Works for any problem — code, architecture, product, design, business, or decisions.

0
installs
▌
Rem Council · darbin bundle
Multi-subagent decision framework for ambiguous tradeoffs where multiple valid options exist. Convenes three independent subagents (Skeptic, Pragmatist, Critic) to surface structured disagreement before committing. Distinct from rem-solve (which finds the answer to a problem) — rem-council arbitrates when you've already framed the options and need pressure-tested deliberation before committing. Use for "which approach should I take", "help me decide between X and Y", "I'm torn between", "weigh the tradeoffs", "sanity check this decision", "monorepo vs polyrepo", "rewrite vs refactor", "ship now vs polish first", architecture forks, tool choices, infrastructure decisions.

0
installs
▌
Rem Handoff · darbin bundle
Session continuity and handoff. Saves current session state for future resumption, or resumes from a previous handoff. Use for handoff, session handoff, context transfer, resume, continue, pick up where I left off, save progress, session state, or context preservation.

0
installs
▌
Rem Audit · darbin bundle
Audit a repo's health across 24 categories - security (injection/auth/headers/secrets), code quality, dead code, DRY, tech debt, resilience, a11y, API contracts. Convention-aware (reads CLAUDE.md/learnings), linter-aware (never duplicates ESLint/biome/vet). Modes - QUICK/STANDARD/DEEP/FOCUSED/PLAN-AWARE/INCREMENTAL/HARNESS. Use for "audit", "repo audit", "full codebase audit", "health check", "security audit", "tech debt inventory", "dead code scan", "pre-release audit", "audit the repo", "--harness", "audit my claude setup", "skill usage health". Distinct from rem-review-code (file/diff-scoped) - rem-audit is repo-wide and health-focused.

0
installs
▌
Rem Plan · darbin bundle
Write a verification-first implementation plan that a fresh subagent could execute without session context. Audits existing capabilities before proposing new code, validates the riskiest assumption first, and gives every task a verification primitive matching its kind. Distinct from rem-review-plan (validates an existing plan) and rem-execute (runs an approved plan). Use for "plan", "implementation plan", "write a plan", "how should we build X", "break this down", "plan this feature", "plan the refactor", or any non-trivial feature, bug fix, or refactor.

0
installs
▌
Rem Test · darbin bundle
Test strategy, generation, and quality audit. Analyzes untested code paths, generates tests matching project patterns, reviews existing test quality, and identifies coverage gaps. Use when the user says "write tests", "add tests", "test this", "check coverage", "review tests", or "what's untested".

0
installs
▌
Rem Feedback · darbin bundle
Capture typed feedback about skill mistakes so skills can learn and improve over time. Writes structured entries to `~/.claude/skill-feedback.jsonl` tagged with one of six mistake types — misrouted (wrong skill fired / should have fired), wrong-output (false claim, bad advice), missed (skill didn't flag an issue it should have), over-flagged (skill flagged a non-issue), context-ignored (skill ignored CLAUDE.md / memory / project conventions), stale (advice references deleted files / old APIs / outdated facts). Links each feedback entry back to the originating invocation in `~/.claude/skill-usage.jsonl` by session_id + timestamp. Auto-promotes to `/rem-skill analyze [name]` when 3+ same-type flags accumulate for one skill. Distinct from rem-learn (which captures project-level lessons, not skill-system lessons) and rem-handoff (session state, not feedback). Use for "flag a skill mistake", "this skill got it wrong", "the skill should have X", "rem-copy misrouted", "rem-review missed the bug", "skill feedback", "

0
installs
▌
Rem Branch · darbin bundle
Finish a development branch. Verifies all tests pass, then presents 4 options - merge locally, push + create PR, keep as-is, or discard. Handles worktree cleanup. Use when the user says "finish branch", "merge", "create PR", "done with this branch", or after rem-execute completes.

0
installs
▌
Rem Verify · darbin bundle
Prove work is complete by running fresh build + typecheck + test + lint commands and showing the output. Never claims done from reasoning alone. Auto-detects stack (Node/Next.js/Go/Rust/Python/Astro/Fastify, monorepos) and runs the matching suite + pre-build scans. Plan-aware mode cross-checks phantom completions and per-Kind Verify evidence. Distinct from rem-review-code (reviews code quality; verify proves it compiles + tests pass) and rem-audit (finds systemic issues; verify proves done-ness). Use for "verify", "is this done?", "check if it works", "run tests", "prove it", "did I break anything". Also invoked by rem-execute and rem-branch.

0
installs
▌
Rem Execute · darbin bundle
Execute an approved implementation plan with maximum discipline - git worktree isolation, TDD per task (RED to GREEN), complexity-scaled review, Codex delegation for mechanical work, one commit per task, and risk-scaled human checkpoints. Distinct from rem-plan (which WRITES the plan), rem-review-plan (which VALIDATES the plan before execution), rem-verify (which runs build/test without executing tasks), and rem-branch (which finishes the branch after execution). Use for "execute", "execute the plan", "run the plan", "implement the plan", "build it", or after /rem-review-plan sets Status to Approved.

0
installs
▌
Rem Review UX · darbin bundle
UX/UI review — Nielsen heuristics, accessibility, visual hierarchy, mobile UX, conversion flow, state coverage, dark patterns. Review UI, review UX, review design, review usability, review this page, check accessibility, a11y review, WCAG audit, UX audit, design review, usability review, UI review, heuristic evaluation. Runs automated a11y audit script (alt text, labels, heading hierarchy, touch targets, landmarks, duplicate IDs, viewport) via Chrome DevTools, then manual review of what the script cannot catch (contrast, focus, keyboard traps, ARIA correctness, cognitive load, dark patterns). Convention-aware — reads CLAUDE.md and learnings first so it never flags intentional design decisions. Distinct from rem-qa (visual/interactive browser testing across many pages; rem-review-ux is heuristic evaluation of a specific page), rem-audit (repo-wide code quality; rem-review-ux is UX-only), rem-cro (conversion optimization strategy; rem-review-ux audits without experimentation), rem-seo (discoverability markup; r

0
installs
▌
Rem Refactor · darbin bundle
Systematic safe refactoring with verification at each step. Resolves DRY violations, splits large files, extracts patterns, removes dead code, and aligns conventions — all while preserving behavior. Use when the user says "refactor", "clean up", "extract", "simplify", "DRY this up", or after rem-audit/rem-review-code identifies issues to fix.

0
installs
▌
Rem Review Code · darbin bundle
Code review for bugs, security, performance, DRY, and maintainability - file-scoped or diff-scoped, not repo-wide. Parallel independent reviewers + a separate verification pass. Auto-detects mode - Plan Verification cross-checks the plan contract against what actually shipped; Diff Review covers recent changes + scope drift; File Review walks listed files. Distinct from rem-audit (repo-wide health) and rem-review-plan (validates the plan BEFORE code). Use for "review code", "review this diff", "review the implementation", "check for bugs", "verify plan was implemented", "review after rem-execute", "code review", or "review these files".

0
installs
▌
Rem Root Cause · darbin bundle
Deep root cause analysis for bugs and errors. Traces execution paths, eliminates wrong hypotheses, finds the underlying architectural problem — not just symptoms. Convention-aware — checks learnings for known issues before investigating. Use when the user has a bug, error, or unexpected behavior and needs to understand why.

0
installs
▌
Rem Review Plan · darbin bundle
Validate an implementation plan BEFORE code is written. Checks Prior Art claims, plan-contract conformance, breakage and bug-introduction risk, convention compliance, premise-wrong exit. Dispatches domain specialists in parallel, iterates up to 3 rounds, and writes Status back to the plan file so rem-execute knows the state. Distinct from rem-plan (writes the plan) and rem-review-code (reviews the implementation). Use for "review this plan", "check my plan", "validate the plan", "is this plan ready", "pre-execute review", "plan review", or after /rem-plan produces a draft.

0
installs

19 published skills