mrpointer
- 28 skills
- 0 followers
- 8 hours ago last updated
- ▌ Linting Go Code · mrpointerLint and format Go code. Use when you need to run linters, fix lint errors, format code, or understand why a linter is complaining.
- ▌ Testing Go Code · mrpointerRun Go unit tests, coverage reports, and benchmarks. Use when you need to run tests, check coverage, run benchmarks, or regenerate mocks after interface changes.
- ▌ Writing Go Code · mrpointerApply Go coding standards when writing or modifying Go code. Use when implementing functions, using dependency injection, handling errors idiomatically, or working with interfaces. For test conventions, use the `writing-go-tests` skill instead.
- ▌ Writing Go Tests · mrpointerWrite Go tests following project conventions. Use when creating test files, writing unit or integration tests, choosing mocks, or setting up test fixtures. Covers test naming, assertions, mock usage, table-driven patterns, and common pitfalls.
- ▌ Developing CLI Apps · mrpointer bundleDevelop CLI applications in Go. Use when creating or modifying CLI commands, adding flags or arguments, implementing command workflows, building interactive prompts, handling signals and exit codes, or working with stdin/stdout/stderr. Currently uses Cobra for command structure and Huh for interactive UI.
- ▌ Building Go Binaries · mrpointerBuild Go binaries for local development or release. Use when you need to compile the project, troubleshoot build failures, or understand the build pipeline.
- ▌ Skill Creator · mrpointer bundleCreate new skills, modify and improve existing skills, and measure skill performance. Use when users want to create a skill from scratch, edit, or optimize an existing skill, run evals to test a skill, benchmark skill performance with variance analysis, or optimize a skill's description for better triggering accuracy.
- ▌ Authoring Rfcs · mrpointer bundleUse when turning a settled design direction, brainstorming outcome, context anchor, or architecture discussion into a codebase-grounded RFC. Produces self-contained RFC documents with verified current architecture, chosen design, tradeoffs, risks, stable references, and planning handoff context without creating implementation plans.
- ▌ Executing Plans · mrpointer bundleUse whenever executing, continuing, resuming, or finishing an implementation plan or plan directory. Orchestrates assigned worker dispatch, integrated test-first discipline, progress checkpointing, isolated workspaces, checkpoint integration, and blocker batching.
- ▌ Anchoring Context · mrpointer bundleMaintain concise feature-level working memory across sessions, teammates, and agents. Use when work spans multiple conversations; involves meaningful decisions, rejected alternatives, unresolved questions, or teammate/subagent handoffs; requires durable context before, during, or after brainstorming, planning, debugging, or implementation; or when the user asks to resume, continue, hand off, preserve context, or keep an anchor updated. When active, update the anchor as decisions are made instead of waiting for an end-of-session summary. Skip for quick one-off questions, trivial edits, and work whose full context fits safely in a single short interaction.
- ▌ Documenting Domain · mrpointerDocument business domain concepts, terminology, entity relationships, and domain rules for a project. Produces documentation that establishes the shared language used by both humans and AI agents. Use when (1) a project's domain concepts are undocumented, (2) agents misinterpret business terminology, (3) onboarding new team members who need to understand the business model, or (4) domain knowledge is scattered across code and needs consolidation. This is the most foundational documentation layer — all other docs reference it.
- ▌ Managing Nono Profiles · mrpointerManage nono sandbox profiles and their shell launch wrappers in this dotfiles repo. Use when editing private_dot_config/nono/profiles, nono profile schemas, dot_agents/shell wrappers, SSH signing access for sandboxed agents, or adding/renaming agent-specific nono profiles.
- ▌ Creating Worker Agents · mrpointer bundleCreate, repair, or update implementation worker agents and runtime bindings. Use whenever the user asks to add a project-local or global implementation worker or custom subagent, a repository lacks a worker for a model tier or technical domain, workers should follow a consistent template, or an existing worker has the wrong model, skills, permissions, or discoverability. Supports OpenCode, Claude Code, and Codex. Do not use for reviewer agents.
- ▌ Documenting Components · mrpointerCreate documentation for specific components or areas of a codebase. Analyzes targeted code sections and produces structured documentation useful to both humans and AI agents. Use when (1) documenting an undocumented component or module, (2) building initial docs for a new area, (3) an agent discovers documentation gaps during codebase exploration, or (4) onboarding documentation is needed for a complex subsystem. Always targets a specific component — never documents the entire codebase at once.
- ▌ Planning Project Epics · mrpointerRoute epic planning to the correct workflow. Recommends RFC-first design when no RFC exists, sends reviewed RFCs to RFC-backed epic planning, and sends explicit opt-outs to direct epic planning.
- ▌ Test Driven Development · mrpointer bundleUse whenever implementing or fixing production code, writing or changing tests, reviewing test quality, applying TDD, or diagnosing tests that pass without proving behavior. Ensures tests are requirement-grounded and reach behavioral RED before implementation.
- ▌ Documenting Architecture · mrpointerDocument system architecture, design decisions, layer boundaries, and how components connect and communicate. Use when (1) a project's architecture is undocumented, (2) agents can't figure out how the system fits together, (3) after major refactoring that changed system structure, or (4) onboarding developers who need to understand the big picture. References domain concepts — never redefines them.
- ▌ Developing Plan Reviewers · mrpointer bundleCreate project-specific plan reviewer agents that integrate with the planning-project-features workflow. Use when a project needs domain-specialized reviewers for sub-plans (e.g., Go code reviewer, API layer reviewer, database reviewer) or when the planner warns that no suitable local reviewer exists for a sub-plan's domain.
- ▌ Planning Project Features · mrpointerRoute feature planning to the correct workflow. Recommends RFC-first design when no RFC exists, sends reviewed RFCs to RFC-backed planning, and sends explicit opt-outs to direct planning.
- ▌ Documenting Library Guides · mrpointerCreate user-facing documentation for libraries — the kind of docs you'd find on a static documentation site. Guides readers through the library with an engaging, conversational tone, real code examples drawn from the actual codebase, and a navigable site-like structure. Use when (1) a library has no user-facing docs beyond inline code comments, (2) existing docs are API references with no narrative guidance, (3) users need task-oriented guides to accomplish common goals, or (4) a library's docs need restructuring into a browsable, site-ready format. Do not use for internal architecture, process, component, or domain docs; use the corresponding documenting-* skill instead.
- ▌ Creating Github Pull Requests · mrpointer bundleCreate GitHub Pull Requests with consistent, high-quality titles and descriptions. Use when opening a PR on GitHub — covers title formatting, summary, decision log, and before/after comparison.
- ▌ Planning Project Epics Direct · mrpointer bundleDecompose large efforts directly from user requirements when no reviewed RFC is available or the user explicitly declines RFC-first epic planning. Produces a persistent epic plan with rich feature descriptions that feed into planning-project-features separately.
- ▌ Documenting Business Processes · mrpointerDocument business processes and workflows that a system implements. Describes end-to-end flows like user registration, order fulfillment, or payment processing — how domain entities move through the system. Use when (1) business workflows are undocumented, (2) a flow spans multiple components and no single component's docs tell the full story, (3) agents need to understand end-to-end behavior to implement changes, or (4) stakeholders need visibility into how the system handles a business process. NOT for development processes — those belong in skills and contribution guidelines.
- ▌ Planning Project Epics From Rfc · mrpointer bundleDecompose a reviewed RFC into sequenced features for a single project. Uses the RFC as the approved design baseline and produces a persistent epic plan reviewed for RFC fidelity and feature decomposition.
- ▌ Planning Project Features Direct · mrpointer bundleCreate implementation plans directly from user requirements when no reviewed RFC is available or the user explicitly declines RFC-first planning. Decomposes work into self-contained sub-plans with full iterative multi-agent plan review.
- ▌ Planning Project Features From Rfc · mrpointer bundleCreate implementation plans from a reviewed RFC. Uses the RFC as the approved design baseline, decomposes it into executable sub-plans, and runs RFC-specific plan review.
- ▌ Managing Chezmoi · mrpointer bundleManage dotfiles with chezmoi. Use whenever editing or reviewing chezmoi source files in this repo, including `dot_*`, `private_dot_*`, `dot_config/`, `private_dot_config/`, `.chezmoitemplates/`, `.chezmoiignore`, and `*.tmpl`; adding files to chezmoi; validating source changes with status/diff/dry-run; debugging source/target mapping or missing changes; or asking how a dotfile is managed. In sandboxed agent work, validate with diff/dry-run and do not run write-capable `chezmoi apply` or `--force`. For command uncertainties, use Context7.
- ▌ Brainstorming · mrpointerUse when exploring a problem space before implementation or planning. Turns rough ideas into validated, codebase-grounded RFCs through collaborative dialogue — challenges assumptions, explores alternatives, and converges on a committed design direction before final RFC authoring.