abildtoft
101 verified skills202 total stars
kramme:siw:spec-audit:team
Audit specification documents for quality using multi-agent execution where dimension specialists collaborate, cross-validate findings, and challenge each other's assessments. Higher quality than standard spec-audit but uses more tokens. Supports inline report output with --inline.
testing2
kramme:pr:ux-review:team
Run UX audit using multi-agent execution where specialized reviewers (usability, product, visual, accessibility) collaborate, cross-validate findings, and challenge each other. Higher quality than standard UX review but uses more tokens. Supports inline report output with --inline.
testing2
kramme:connect:modernize-angular
Use this Skill when working in the Connect monorepo and needing to modernize legacy Angular components.
tools2
kramme:connect:document-feature
Use this skill when you are creating documentation for an existing Connect feature or updating existing docs
documentation2
kramme:skill:review
Reviews plugin skills for focused scope, progressive disclosure, portability, safety, retry behavior, and documentation quality. Use when auditing a SKILL.md, skill directory, or proposed skill text against skill-authoring standards. Not for creating new skills, editing skills, or reviewing ordinary application code.
tools2
kramme:pr:resolve-review:team
Resolve review findings in parallel using multi-agent execution. Groups findings by file area and assigns to separate agents for faster resolution. Best when review has 5+ findings across different areas.
data-ai2
kramme:siw:implementation-audit:team
Exhaustively audit codebase implementation against specification using multi-agent execution where conformance and extension agents collaborate, challenge each other's findings in real time, and run simultaneous passes. Higher quality than standard implementation-audit but uses more tokens. Supports inline report output with --inline.
tools2
kramme:verify:before-completion
Use when about to claim work is complete, fixed, or passing, before committing or creating PRs - requires running verification commands and confirming output before making any success claims; evidence before assertions always
testing2
kramme:code:copy-review
Scan the codebase (or a specified scope) for unnecessary, redundant, or duplicative UI text. Identifies labels, descriptions, placeholders, tooltips, and instructions that could be removed because the UI already communicates the same information through its structure.
tools2
kramme:code:frontend-authoring
Build production-quality UI components with sound architecture, accessibility (WCAG 2.1 AA), and anti-AI-aesthetic defaults. Use when creating or modifying user-facing components. Covers component colocation, composition over configuration, state-management tier selection, accessibility patterns, and concrete replacements for AI-aesthetic defaults (purple gradients, rounded-2xl everywhere, oversized padding, shadow-heavy cards).
development2
kramme:code:zoom-out
Map the modules and call relationships in an area in focus. Use when the user is unfamiliar with a section of code and wants a one-shot orientation — modules involved, what they do, who calls what. Not for full-repo scans (use kramme:code:refactor-opportunities); not for bug investigation (use kramme:debug:investigate); not for visualizations (use kramme:visual:diagram).
development2
kramme:launch:rollout
Execute a post-merge launch with staged rollout, numeric decision thresholds, and rollback triggers. Sequence — staging → prod (flag OFF) → team enable → 5% canary → 25→50→100% gradual → full rollout + 1-week monitor + flag cleanup. Use after merging a user-facing change that needs safe rollout. Complements kramme:pr:finalize (pre-merge readiness) with post-merge verification, canary gates, and rollback paths. Not for PR creation, CI debugging, or pre-merge checks.
development2
kramme:siw:reverse-engineer-spec
Reverse engineer an SIW specification from existing code. Analyzes a git branch diff, folder, or file set to produce a structured spec compatible with the SIW workflow. Use when code exists without documentation, onboarding to unfamiliar code, or bootstrapping SIW from an existing implementation.
development2
kramme:pr:code-review:team
Run comprehensive PR review using multi-agent execution where specialized reviewers collaborate, cross-validate findings, and challenge each other. Higher quality than standard review but uses more tokens. Supports inline report output with --inline.
development2
kramme:visual:project-recap
Generate a visual HTML project recap to rebuild mental model when returning to a project — architecture snapshot, recent activity timeline, decision log, and cognitive debt hotspots
development2
kramme:test:tdd
(experimental) Drive implementation with tests. Write a failing test that characterizes the requirement or reproduces the bug, implement the minimum to pass, then refactor with tests green. Use when implementing new logic, fixing a bug (Prove-It pattern), or changing behavior. Complementary to kramme:test:generate, which writes tests for existing untested code.
development2
kramme:hooks:toggle
Enable, disable, list, or reset hook toggles for the kramme-cc-workflow plugin. Use when a hook is firing unwantedly, when a new hook needs to be switched on, or when the user asks about current hook state.
tools2
kramme:docs:out-of-scope
(experimental) Record, check, append, or reconsider rejected enhancement concepts in the project's `.out-of-scope/` directory. One markdown file per concept; substantive reason + prior-request list. Use when the team rejects an enhancement and wants to remember why, or when checking whether a new request matches a prior rejection. Not for bug rejections (close as wontfix with a comment), not for deferrals (use issue priority/status instead), not for cross-repo aggregation.
testing2
kramme:code:rewrite-clean
Scrap a working-but-mediocre fix and reimplement elegantly. Use after making a fix that works but feels hacky. Applies Chesterton's Fence before scrapping, emits SIMPLICITY CHECK at design time, and rejects rewrites that require modifying tests to pass.
development2
kramme:pr:plan-split
Analyze the current branch's diff and break it into smaller, independently mergeable PRs. Categorizes changes by feature, layer, and module; detects coupling; and proposes a concrete seam (vertical, stack, by file group, or horizontal — preferring vertical) for each slice with file lists, line counts, dependency order, test plan, and rationale. Hands the slices to kramme:code:breakdown-findings to write the PR_PLAN_*.md artifacts, supplying a worktree-based implementation setup that extracts each slice's changes from the branch the skill is run in. Use before opening a PR that bundles unrelated work, when a reviewer asks for a split, or when a branch has grown too large to review. Plans only; does not edit source code, create branches, or rewrite git history.
development2
kramme:browse
(experimental) Browser operator for live product inspection. Detects available browser MCP tooling (claude-in-chrome, chrome-devtools, playwright) and provides consistent navigation, screenshots, interaction, and evidence capture. Not for code-only analysis.
tools2
kramme:code:api-design
(experimental) Design stable APIs and module boundaries. Covers contract-first approach, Hyrum's Law, validation placement (at boundaries, not between internal functions), consistent error shapes with HTTP status mapping, naming conventions, and TypeScript patterns for interface stability. Use when adding HTTP endpoints, public modules, SDK surfaces, or any interface with external or cross-team callers. Includes a Design It Twice mode (opt-in via --design-twice or the phrase 'design it twice') that drafts radically different shapes — in parallel via sub-agents on Claude Code, sequentially elsewhere — before committing to one.
development2
kramme:code:deprecate
Plan and execute deprecation of code, features, APIs, or modules, treating code as a liability. Covers the decision to deprecate (5-question checklist), Hyrum's Law risk assessment, Advisory vs Compulsory deprecation paths, Strangler / Adapter / Feature-Flag migration patterns, and a four-step workflow: build replacement → announce → migrate incrementally → remove old. Emits SIMPLICITY CHECK, NOTICED BUT NOT TOUCHING, UNVERIFIED, and ASK FIRST markers. Use when removing legacy systems, sunsetting features, retiring API versions, or cleaning up zombie code with unknown owners.
development2
kramme:code:harden-security
Apply security-by-default when writing code that handles user input, authentication, data storage, or external integrations. Use when building features that accept untrusted data, manage user sessions, or call third-party services. Complements the review-time auth-reviewer / data-reviewer / injection-reviewer agents with author-time guardrails.
development2
kramme:code:incremental
(experimental) Deliver changes in small, verified slices with scope discipline, incremental verification between slices, and feature-flag guardrails for incomplete work. Use when implementing any change that spans more than one file or commit. Enforces one-thing-at-a-time, rollback-friendly commits, and explicit separation of in-scope work from noticed-but-untouched observations. Includes a refactor mode (opt-in via --refactor or after kramme:code:refactor-opportunities) that adds an interview-driven Decision Document and a Fowler-style tiny-commits plan where every intermediate state leaves the codebase working.
development2
kramme:code:refactor-pass
Perform a refactor pass focused on simplicity after recent changes. Use when the user asks for a refactor/cleanup pass, simplification, or dead-code removal on a narrow scope and expects build/tests to verify behavior. Applies Chesterton's Fence before removing code, rejects simplifications that require modifying tests, and works one slice at a time.
development2
kramme:code:refactor-opportunities
Scan the full codebase, current PR, a named file/folder, or a named feature for refactoring candidates. Use when the user asks to find refactor opportunities, audit code quality, identify tech debt, or wants a codebase health check. Flags themes whose combined blast radius exceeds 500 lines as automation candidates.
tools2
kramme:docs:adr
Author Architecture Decision Records for significant, long-lived decisions. Creates ADRs in docs/decisions/ with sequential numbering and lifecycle states (PROPOSED / ACCEPTED / SUPERSEDED / DEPRECATED). Detects and preserves existing ADR format when one is in use; falls back to a Nygard-style template otherwise. Use when adopting a new pattern, committing to a dependency, changing a public interface, changing the data model, or rejecting an alternative a future maintainer might reasonably re-propose. For in-project decisions during a tracked SIW initiative use /kramme:siw:close's decision log instead.
development2
kramme:debug:triage-to-issue
(experimental) Triage a bug end-to-end: orchestrate root-cause investigation, design a TDD fix plan with RED-GREEN cycles, and file a refactor-durable Linear or local SIW issue in one mostly-hands-off pass. Use when a bug needs to become an implementation-ready ticket without manually chaining kramme:debug:investigate, kramme:test:tdd, and kramme:linear:issue-define. Composes kramme:debug:investigate and kramme:linear:issue-define via skill invocation; captures kramme:test:tdd conventions inline in v1. Not for the full interactive investigation with confidence gates (use kramme:debug:investigate alone), not for conversational multi-bug QA-intake sessions (use kramme:qa:intake), not for implementing the fix (use kramme:linear:issue-implement or kramme:siw:issue-implement after this skill files the ticket).
development2
kramme:debug:investigate
Structured bug investigation workflow: reproduce, isolate, trace root cause, and fix. Use when debugging a bug, investigating an error, or tracking down a regression.
development2
kramme:deps:audit
(experimental) Audit project dependencies for outdated packages, security vulnerabilities, and staleness. Generates a prioritized upgrade plan with risk assessment.
testing2
kramme:discovery:interview
Conduct an in-depth interview about a topic/proposal to uncover requirements, priorities, and non-goals, then create a comprehensive plan. Pass --ideate for divergent framing, --decision-tree / depth-first language to resolve tightly coupled decisions one question at a time, or --research to launch topic-specific research agents before the interview.
development2
kramme:docs:add-greenfield-policy
Add the Hard-Cut Greenfield Policy section to AGENTS.md or CLAUDE.md. Use when setting up a new greenfield project or adding the no-compatibility-code policy to an existing project. Not for editing or customizing the policy after it has been added.
development2
kramme:docs:ubiquitous-language
Extract a DDD-style ubiquitous language glossary from the current conversation, flagging ambiguities and proposing canonical terms. Saves to UBIQUITOUS_LANGUAGE.md at the repo root. Use when the user wants to define domain terms, build a glossary, harden terminology, or mentions 'ubiquitous language' or 'DDD'. Not for general programming concepts (array, function, endpoint), code-level type/class glossaries, or per-feature naming inside a single module.
development2
kramme:docs:update-agents-md
This skill should be used when the user asks to "update AGENTS.md", "add to AGENTS.md", "maintain agent docs", or needs to add guidelines to agent instructions. Guides discovery of local skills and enforces structured, keyword-based documentation style.
documentation2
kramme:hooks:configure-links
Configure the context-links hook by updating hooks/context-links.config with workspace, team key, and issue regex overrides. Use when end users want to set up or change context-links behavior without manually editing files.
tools2
kramme:linear:issue-implement
Start implementing a Linear issue with branch setup, context gathering, and guided workflow
documentation2
kramme:changelog:generate
Produce a witty daily or weekly changelog summarizing recent PRs merged to the main branch — grouped into breaking changes, features, fixes, and other improvements, with contributor shoutouts. Use for release notes or summaries of recent changes. Returns changelog text only; reads PRs read-only and writes or sends nothing.
documentation2
kramme:linear:issue-define
Create or improve a well-structured Linear issue through exhaustive guided refinement
documentation2
kramme:pr:finalize
(experimental) Final PR readiness orchestration. Coordinates verify:run, pr:code-review, pr:product-review, pr:ux-review, qa, and pr:generate-description. Produces a ready/not-ready/ready-with-caveats verdict. Not for creating PRs, fixing CI, or merging code.
development2
kramme:pr:design-pipeline
Design a CI/CD pipeline with quality gates, a <10-minute budget, feature-flag lifecycle, and an exit checklist. Use when adding a new CI pipeline, changing gate configuration, or planning a rollout for a new service. Complementary to kramme:pr:fix-ci (which fixes failures in an existing pipeline). Covers gate ordering, secrets storage, branch protection, rollback mechanism, and staged-rollout guardrails — not a rollout-execution runbook.
testing2
kramme:code:cleanup-ai
Remove AI-generated code slop from a branch. Use when cleaning up AI-generated code, removing unnecessary comments, defensive checks, or type casts. Checks the branch diff against the resolved base and fixes style inconsistencies. Not for generated, vendored, lockfile, snapshot, or `*.d.ts` files.
development2
kramme:pr:create
Use when creating a PR from the current branch with narrative-quality commits and a generated description. Orchestrates branch setup, commit restructuring via kramme:git:recreate-commits, and description generation via kramme:pr:generate-description before pushing and opening the PR via gh.
testing2
kramme:siw:discovery
Deep discovery interview that uncovers what you actually want, not what you think you should want. Works pre-spec or on existing specs until 95% confident. Pass --decision-tree, or ask to walk depth-first, to resolve tightly coupled decisions one at a time.
testing2
kramme:siw:breakdown-findings
Break down unresolved spec-audit or implementation-audit findings into executive summaries, resolution options, and a recommendation without creating SIW issues. Use it after spec-audit, spec-audit:auto-fix, or implementation-audit when you want decision-ready analysis before choosing a follow-up path. Not for product audits or direct issue creation.
testing2
kramme:code:performance
(experimental) Measure-first performance discipline tied to Core Web Vitals (LCP, INP, CLS). Use when users or monitoring report slowness, CWV scores miss thresholds, performance requirements exist in the spec, you suspect a recent change introduced a regression, or you're building features that handle large datasets or high traffic. Enforces baseline measurement, single-bottleneck fixes, verification, and regression guards. Complements the review-time `performance-oracle` agent.
development2
kramme:pr:product-review
Deep product review of branch and local changes. Evaluates user-value alignment, flow completeness, missing states, copy/defaults, permission behavior, adjacent-flow regressions, and prioritization quality. Infers likely user goals and non-goals when rationale is missing. Not for UX heuristics, accessibility, or visual consistency -- use pr:ux-review for those. Supports inline report output with --inline.
development2
kramme:product:design-critic
(experimental) Sharpen product design judgment for software UI/UX, interaction flows, jobs-to-be-done, hierarchy, trust, governance surfacing, and competitor-informed critique. Use when critiquing or shaping a product surface, card, panel, workflow, chat experience, or design strategy instead of merely suggesting visual polish.
development2
kramme:pr:rebase
Rebase current branch onto latest main/master, then force push. Use when your PR is behind the base branch.
testing2
kramme:pr:verify-description
Compare an existing PR's title and body against the actual branch diff and report drift — false claims, missing major changes, stale scope, missing risk callouts. Use after pushing changes to a branch with an open PR, or before requesting review. Read-only by default; add --fix to delegate to kramme:pr:generate-description for an updated description. Complements kramme:pr:code-review (which checks description accuracy as one signal among many code-quality checks) by being a fast, focused, single-purpose check that runs in seconds.
development2
kramme:pr:resolve-review
Resolve findings from code reviews by implementing fixes and documenting changes. Use --team to resolve independent findings in parallel by file area.
development2
kramme:pr:ux-review
Audit UI, UX, and product experience of PR and local changes using specialized agents for usability heuristics, product thinking, visual consistency, and accessibility. Supports inline report output with --inline. Use --team for multi-agent cross-validation.
testing2
kramme:qa:intake
Conversational QA intake session - user describes bugs they encountered, the agent lightly clarifies, explores the codebase in the background for domain language, and files durable Linear or SIW tickets one issue at a time. Use when the user has multiple bugs from a manual QA pass and wants to log them rapidly without per-issue deep interviews. Not for live-app browser testing (use kramme:qa), not for tracing the root cause of a single bug or applying a fix (use kramme:debug:investigate), not for one well-refined ticket with a 5-round interview (use kramme:linear:issue-define).
development2
kramme:product:review
(experimental) Whole-product review across flows and surfaces. Requires a live app URL. Evaluates navigation coherence, feature discoverability, onboarding, cross-flow consistency, dead ends, friction, and trust/safety. Produces PRODUCT_AUDIT_OVERVIEW.md, or replies inline with --inline. Not for branch-scoped PR review (use pr:product-review) or pre-implementation spec audit (use siw:product-audit).
development2
kramme:session:wrap-up
End-of-session checklist to capture progress, ensure quality, and document next steps
testing2
kramme:siw:continue
Entry point for the Structured Implementation Workflow (SIW) — a local, markdown-based workflow for planning, tracking, and implementing multi-step work. Resumes in-flight SIW runs by reading siw/LOG.md and siw/OPEN_ISSUES_OVERVIEW.md, or routes new work to the right SIW subcommand. Triggers on "SIW", "structured workflow", or when siw/LOG.md and siw/OPEN_ISSUES_OVERVIEW.md files are detected.
tools2
kramme:siw:generate-phases
Break spec into atomic, phase-based issues with tests and validation
testing2
kramme:code:source-driven
(experimental) Ground framework and library decisions in official documentation with explicit citation. Use when touching any external framework, library, CLI tool, or cloud service — especially recent versions where training data may be stale. Fetches via Context7 MCP or direct URLs, implements against documented patterns, and cites deep links with quoted passages when decisions are non-obvious.
tools2
kramme:siw:init
Initialize structured implementation workflow documents in siw/ (spec, LOG.md, issues)
documentation2
kramme:siw:issue-define
Define or improve a local SIW issue file through a guided interview. For Linear or other external trackers use kramme:linear:issue-define.
documentation2
kramme:siw:resolve-audit
Resolve audit findings one-by-one with executive summaries, alternatives, recommendation, and SIW issue creation
testing2
kramme:siw:remove
Delete SIW workflow files from the current directory. Destructive; use kramme:siw:close first if you want to preserve documentation.
documentation2
kramme:siw:spec-audit
Audit specification documents for quality — coherence, completeness, clarity, scope, actionability, testability, value proposition, and technical design. Catches spec issues before implementation begins. Supports inline report output with --inline. Use --team for multi-agent cross-validation.
testing2
kramme:docs:feature-spec
Author a lightweight PRD-style feature spec before implementation. Produces a single reviewable markdown artifact covering objective, scope, boundaries, assumptions, non-goals, and testing strategy. Use when starting a feature that needs written alignment before coding but does NOT warrant the full siw/ tracked workflow. Pass --synthesize (or say "draft straight from context") to skip the assumptions block when the current conversation already grounds enough of the spec. For tracked initiatives (phased issues, LOG, audit) use kramme:siw:init instead.
development2
kramme:siw:spec-audit:auto-fix
Auto-fix mechanical spec-audit findings that have a single obvious correct resolution — cross-reference errors, terminology inconsistencies, numbering mistakes, formatting issues, and weasel words replaceable with specifics already in the spec. Run after spec-audit.
development2
kramme:verify:run
Run verification checks (tests, formatting, builds, linting, type checking) for affected code based on the project's configuration.
development2
kramme:code:migrate
(experimental) Plan and execute framework or library version migrations with phased upgrades and verification gates. Use when upgrading major framework versions (Angular, React, Node) or migrating between libraries.
development2
kramme:text:humanize
Remove signs of AI-generated writing from text to make it sound natural and human-written. Use when editing or reviewing prose for AI-isms. Can write the result back to a source file on confirmation. Not for code, quoted passages, or text that must stay verbatim.
development2
kramme:visual:generate-image
Generate and edit images using Google's Gemini 3 Pro Image API. Use when the user asks to generate, create, edit, modify, change, alter, or update images. Also use when user references an existing image file and asks to modify it in any way (e.g., "modify this image", "change the background", "replace X with Y"). Supports both text-to-image generation and image-to-image editing with configurable resolution (1K default, 2K, or 4K for high resolution). DO NOT read the image file first - use this skill directly with the --input-image parameter.
development2
kramme:test:generate
(experimental) Generate tests for existing code by analyzing project test patterns and conventions. Use when adding test coverage to untested files or generating test stubs.
development2
kramme:docs:to-markdown
Convert documents and files to Markdown using markitdown. Use when converting PDF, Word (.docx), PowerPoint (.pptx), Excel (.xlsx, .xls), HTML, CSV, JSON, XML, images (with EXIF/OCR), audio (with transcription), ZIP archives, YouTube URLs, or EPubs to Markdown format for LLM processing or text analysis.
development2
kramme:git:commit-message
Create commit messages for branch commits. Use when committing code changes or writing commit messages. Covers plain-English commit format, a pre-commit checklist, and AI-attribution rules. Not for PR titles or merge commits, which use Conventional Commits.
development2
kramme:code:breakdown-findings
Cluster validated findings into PR-sized themes and generate self-contained implementation plans. Use after review, audit, scan, or QA workflows that produce findings reports. Also accepts a pre-clustered handoff from a delegating skill (themes already grouped, mapped one-to-one to plans) plus an optional shared implementation-setup block rendered into every plan. Not for raw bug lists without severity or location structure, and not for triaging a single issue.
development2
kramme:git:recreate-commits
Use when asked to recreate commits with narrative-quality history on the current branch.
testing2
kramme:nx:setup-portless
Set up portless in an Nx workspace with dev:local/dev:full targets. Use when adding portless to an Nx project or wiring up Nx targets for local HTTPS development.
development2
kramme:pr:code-review
Analyze code quality of branch changes using specialized review agents (tests, errors, types, security, performance, slop). Outputs REVIEW_OVERVIEW.md with actionable findings, or replies inline with --inline. Use --team for multi-agent cross-validation. Not for UX, visual, or accessibility review -- use kramme:pr:ux-review for those.
development2
kramme:visual:plan-review
Generate a visual HTML plan review comparing current codebase state vs. a proposed implementation plan, with architecture diagrams, blast radius analysis, and risk assessment
development2
kramme:git:fixup
Intelligently fixup unstaged changes into existing commits on the current branch. Maps each changed file to its most recent commit, validates (build/test/lint), creates fixup commits, and autosquashes.
development2
kramme:pr:generate-description
Write a structured PR title and body from git diff, commit log, and Linear context. Outputs markdown for copy-paste or, when explicitly invoked with --auto, updates an existing PR.
testing2
kramme:pr:copy-review
Review PR and local changes for unnecessary, redundant, or duplicative UI text — labels, descriptions, placeholders, tooltips, and instructions that the UI already communicates through its structure. Supports inline report output with --inline.
tools2
kramme:session:context-setup
Configure effective agent context at session start or after output quality degrades. Covers rules-file verification (CLAUDE.md / AGENTS.md), pre-task context loading (files to modify + related tests + one similar-pattern example + type definitions), context-window hygiene, and trust-level tagging for inputs. Use when starting a new session, switching major tasks, or when output quality drops. Not for trivial single-file edits or mid-task incremental loads — it is a session-boundary ritual, not a per-edit step.
development2
kramme:siw:implementation-audit
Exhaustively audit codebase implementation against specification. Detects spec divergences, undocumented implementation extensions, contract violations, and spec drift. Supports inline report output and an optional team mode for multi-agent cross-validation.
tools2
kramme:siw:close
Close an SIW project by generating permanent documentation in docs/<feature>/ and removing temporary workflow files
documentation2
kramme:siw:issue-reindex
Remove all DONE issues and renumber remaining issues within each prefix group. Not for editing live issue content, archiving still-open issues, or moving issues between prefix groups.
data-ai2
kramme:siw:product-audit
(experimental) Product audit of SIW specs and plans before implementation. Evaluates target user clarity, problem/solution fit, user state modeling, critical moments coverage, scope correctness, success criteria quality, and prioritization quality. Infers likely user goals and non-goals when the spec is incomplete. Not for code review or implementation auditing. Supports inline report output with --inline.
development2
kramme:visual:onboarding
Generate an interactive HTML onboarding guide for newcomers to a codebase — architecture overview, domain model, key flows, conventions, and getting-started walkthrough.
development2
kramme:visual:diagram
Generate beautiful, self-contained HTML pages that visually explain systems, code changes, plans, and data. Use when the user asks for a diagram, architecture overview, flowchart, schema, or any visual explanation of technical concepts. Also use proactively when about to render a large ASCII table (4+ rows and 3+ columns) — present it as a styled HTML page instead.
development2
kramme:visual:diff-review
Generate a visual HTML diff review with before/after architecture comparison, KPI dashboard, Mermaid dependency graphs, and code review analysis
development2
kramme:connect:extract-nx-libs
Use this Skill when working in the Connect monorepo and needing to extract app code into proper Nx libraries.
development2
kramme:siw:issue-implement:team
Implement multiple SIW issues in parallel using multi-agent execution. Each agent gets a full context window and implements one issue. Best for phases with multiple independent issues.
data-ai2
kramme:siw:issues-reindex
Remove all DONE issues and renumber remaining issues within each prefix group
data-ai2
kramme:connect:rive-docs
Official Rive documentation covering editor, scripting, runtimes, data binding, and feature support. Primary focus on iOS/mobile integration.
testing2
kramme:connect:migrate-store-ngrx
Use this Skill when working in the Connect monorepo and needing to migrate legacy CustomStore or FeatureStore implementations to NgRx ComponentStore.
tools2
kramme:code:agent-readiness
Audit a codebase for agent-nativeness — score how well-optimized it is for AI coding agents across 5 dimensions and generate a prioritized refactoring plan.
development2
kramme:qa
Structured QA testing with evidence capture. Runs smoke checks, diff-aware validation, or targeted route testing against a live app. Produces QA_REPORT.md with screenshots, repro steps, severity, and recommended fixes, or replies inline with --inline. Uses browser MCP when available and falls back to code-only analysis otherwise. Not for logging multiple bugs from a manual pass (use kramme:qa:intake) or tracing one bug's root cause (use kramme:debug:investigate).
tools2
kramme:siw:reset
Reset SIW workflow state while preserving the spec - migrates log decisions to spec, clears issues and log
testing2
kramme:siw:issue-implement
Start implementing a defined local issue with codebase exploration and planning. Use --team to implement multiple independent SIW issues in parallel.
development2
kramme:skill:create
Guide the creation of a new Claude Code plugin skill with best-practice structure, optimized frontmatter, and progressive disclosure. Use when creating a new skill from scratch or scaffolding a skill directory. Not for editing or refactoring existing skills.
tools2
kramme:workflow-artifacts:cleanup
Delete workflow artifacts — review and audit overviews, QA reports, generated PR plans, SIW tracking files, and visual diagram HTML — from the working directory and the shared diagrams folder. Confirms before deleting; SIW specification files are kept unless you explicitly include them. Recoverable via Trash when `trash` is installed, otherwise permanent.
development2
kramme:pr:fix-ci
Iterate on a PR until CI passes. Use when you need to fix CI failures, address review feedback, or continuously push fixes until all checks are green. Automates the feedback-fix-push-wait cycle.
testing2
kramme:session:automate-repeats
Reviews recent agent session transcripts to find repeated manual workflows or repeated user asks, then proposes and optionally scaffolds only useful new skills or custom subagents. Use when the user asks to inspect recent sessions, find automation opportunities, or create reusable workflows from repeated work. Not for summarizing one session, general retrospectives, or codebase refactoring.
tools2