convez.ai
MCP Server
michaelalber

ai-toolkit

michaelalber/ai-toolkit

Ver no GitHub
InicialPluginScore · de 0 a 100

Production-ready AI coding skills and agents for Claude Code, OpenCode, and Pi. Covers TDD, .NET, Python, Rust, edge AI, and more.

Instalação

$npx convez-ai michaelalber/ai-toolkit

1 comando no terminal: detecta o formato do repositório (marketplace ou plugin avulso) e instala via Claude Code. Requer Node 18+ e o Claude Code instalado.

Métricas

Estrelas
3
Forks
0
Acompanhando
0
Saúde
42%
Último commit
há 5 dias
Versão
—
Issues abertas
0
Contribuidores
3

README

A tradução para o português deste README ainda está na fila.

AI Toolkit

License: MIT Skills Agents Platforms

103 skills, 49 agents, and 22 slash commands for AI-assisted software development — spanning TDD, .NET, Python, PHP, Rust, React, edge AI, security, DDD, and more.

Works with Claude Code, OpenCode, and Pi (Ollama local models).


Why I built this

I work across a wide range of domains — enterprise .NET, Python, Rust, edge AI, robotics, and federal security compliance. As AI coding assistants became central to my workflow, I found myself writing the same guidance over and over: how to run a proper TDD cycle, how to review code for OWASP compliance, how to scaffold a vertical slice feature correctly.

This toolkit encodes that expertise as reusable primitives. Each skill is an opinionated, structured prompt that reflects how I actually work — not a generic template. The result is an AI coding assistant that reasons the way I'd want a senior engineer to reason: with discipline, with domain knowledge, and with the right tradeoffs in mind.

Design decisions:

  • Three primitives, one toolkit — skills (model-invoked expertise), agents (autonomous executors), commands (user-triggered with live shell context). Each has a distinct role.
  • Platform parity — every skill and agent exists in both Claude Code and OpenCode format with identical behavior. Pi gets its own Ollama-optimized config.
  • Two-tier skill design — full-template skills (5-section lean layout: philosophy, workflow, state, output-template pointers, integrations; depth such as principle tables, anti-patterns, and error recovery loads on demand from references/) for domain-expert tools; minimal-tier skills (≤ 100 lines, focused instructions) for mode switches and conversational tools.
  • Global + project layered config — global standards apply everywhere; project-level files add specificity without duplicating the global.

At a glance

Count
Skills (team)85
Skills (professional)18
Agents (Claude Code)49
Agents (OpenCode)49
Slash commands (per platform)22
PlatformsClaude Code, OpenCode, Pi

How it works

Three distinct primitives compose the toolkit:

Skills — Structured, opinionated prompt files that encode domain expertise. Model-invoked autonomously. Live in skills/{team,professional}/<name>/SKILL.md. Full-template skills follow a 5-section lean layout with depth in references/.

Agents — Autonomous executors that combine skills with tool access and guardrails. Operate independently within defined boundaries. Live in claude/agents/ and opencode/agents/.

Commands — User-triggered slash commands (type /command-name) that inject live shell state before the model acts. Live in claude/commands/ and opencode/commands/.

User types /tdd
    → command injects live dotnet test output
    → model reads failing tests
    → tdd skill drives RED-GREEN-REFACTOR
    → hooks run dotnet build after every file write

Platforms

PlatformProviderPrivacyBest for
Claude CodeAnthropic subscriptionCloudBest reasoning, MCP ecosystem, Claude-native workflows
OpenCodeAny cloud provider (Anthropic, OpenAI, Google, Mistral…)CloudProvider flexibility, multi-model teams
PiOllama local models (7B–32B)Fully offlineZero API cost, privacy-first, air-gapped use

Claude Code

# Skills (both team and professional by default)
mkdir -p ~/.claude/skills
ln -sf /path/to/ai-toolkit/skills/team/*/ ~/.claude/skills/
ln -sf /path/to/ai-toolkit/skills/professional/*/ ~/.claude/skills/

# Agents
mkdir -p ~/.claude/agents
ln -sf /path/to/ai-toolkit/claude/agents/team/*.md ~/.claude/agents/
ln -sf /path/to/ai-toolkit/claude/agents/professional/*.md ~/.claude/agents/

To install only the team-facing skills (e.g. when sharing this with a colleague), omit the professional/ lines.

See claude/global/README.md for global config setup (hooks, permissions, commands).

OpenCode

mkdir -p ~/.config/opencode/skills
ln -sf /path/to/ai-toolkit/skills/team/*/ ~/.config/opencode/skills/
ln -sf /path/to/ai-toolkit/skills/professional/*/ ~/.config/opencode/skills/

mkdir -p ~/.config/opencode/agents
ln -sf /path/to/ai-toolkit/opencode/agents/team/*.md ~/.config/opencode/agents/
ln -sf /path/to/ai-toolkit/opencode/agents/professional/*.md ~/.config/opencode/agents/

# Commands
mkdir -p ~/.config/opencode/commands
ln -sf /path/to/ai-toolkit/opencode/commands/*.md ~/.config/opencode/commands/

See opencode/global/README.md for provider config, Ollama tuning, and permissions.

Pi (Ollama / Local Models)

bash scripts/install-pi.sh         # 7B-safe default
bash scripts/install-pi.sh --full  # 20B variant

See pi/global/README.md for the full Ollama setup guide — Modelfile config, compaction tuning, model selection by VRAM.

Other AI tools (Cursor, Windsurf, Copilot, etc.): AGENTS.md follows the universal agent instructions standard and is auto-discovered from the project root.


Skills

This toolkit is organized in two folders. skills/team/ contains skills and agents I use in production work and consider shareable — patterns extracted from years of enterprise .NET, legacy modernization, and AI-augmented development on regulated-industry codebases. It also incorporates several vendored workflow-primitive skills from Matt Pocock's repo (see Companion Skills below). skills/professional/ is my professional-development track: deliberate-practice loops that sharpen engineering judgment (architecture critique, code review, pattern selection, refactoring prioritization) and learning scaffolds for the professional domains I'm actively growing into (edge AI, robotics, sensor integration). These are career-skill investments, not side projects — the split keeps "what I ship for the team" distinct from "the competencies I'm deliberately building."

Companion Skills

This toolkit incorporates several skills from Matt Pocock's skills repo alongside my own. Vendored copies carry source: mattpocock/skills in their frontmatter along with the upstream commit hash they were pulled from, so the provenance is traceable. Matt updates frequently — periodically check his repo and re-vendor when meaningful changes land.

Matt's skills cover the workflow primitives that apply to any project regardless of stack: grilling a plan until it's coherent (grill-me), driving the red-green-refactor loop (to-prd, to-issues), zooming out to understand a call chain (zoom-out), switching to a compressed communication mode (caveman), and improving a codebase's module structure (improve-codebase-architecture). They're small, composable, and deliberately stack-agnostic — exactly the layer my own skills don't try to replicate.

The skills I've written cover the domain-specific layers that sit on top: enterprise .NET patterns (vertical slice, CQRS, EF Core migrations, federal-compliance security review), AI/ML infrastructure (RAG pipelines, MCP server scaffolding, local LLM workflows), edge AI and robotics (Jetson deployment, sensor integration, CV pipelines), and the coaching loops in my professional-development track that build architectural and review judgment.

The two layers are non-overlapping by design. Where they look adjacent — Matt's to-prd vs. my triage-issue, his improve-codebase-architecture vs. my architecture-review — each is solving a different layer. Matt's is the workflow primitive; mine is the domain-calibrated, opinionated version for a specific stack or practice context.

See .matt-pocock-attribution.yml at the repo root for the full provenance manifest, including modification notes for each vendored skill.

skills/team/

TDD Suite

SkillDescription
tddCanonical RED-GREEN-REFACTOR inner loop — the one TDD skill. Enforces behavioral, structure-insensitive tests, prohibits horizontal slicing, and carries GREEN strategies + per-language idioms and the REFACTOR smell catalog in its references/.
tdd-agentOperating mode: AI drives all phases autonomously with strict guardrails and verification at each step. Defers to tdd for the loop.
tdd-pairOperating mode: collaborative TDD with role-based pairing — Ping-Pong, Navigator, and Teaching. Defers to tdd for the loop.
evaluate-testsAudits existing tests in two modes — test-file quality (prioritized rewrite list) and TDD compliance (commit-history scorecard + anti-patterns).

Enterprise .NET Suite

SkillDescription
dotnet-vertical-sliceScaffold vertical slice architecture with CQRS + FreeMediator + optional Telerik Blazor UI generation.
ef-migration-managerEF Core migration lifecycle with safety checks, data loss detection, SQL review, and rollback verification.
nuget-package-scaffoldNuGet package creation with multi-targeting, CI/CD pipelines, and semantic versioning.
legacy-migration-analyzer.NET Framework to .NET 10 migration analysis with risk scoring, upgrade strategies, and incremental patterns.
dotnet-architecture-checklist.NET architecture review — detects style and grades both layered/N-tier controller APIs and vertical-slice CQRS/Blazor.
dotnet-security-reviewOWASP-based .NET security review with Telerik specialization and manager-friendly reporting.
security-review-federalShared, language-agnostic federal/gov overlay for any base security review — NIST 800-53, FIPS 140-2/3, CUI, POA&M, EO 14028, DOE 205.1B.
minimal-api-scaffolder.NET 10 minimal API scaffolding with OpenAPI documentation, versioning, and security patterns.
dotnet-controller-api-scaffolderController-based ASP.NET Core Web API scaffolding that detects and conforms to an existing codebase's conventions (base controller, validation, service/mediator boundary, response shape).
4d-schema-migration4D (4th Dimension) to SQL Server/EF Core/Blazor full-stack migration specialist.
(planned) shared-kernel-generator.NET shared kernel scaffolding — not yet implemented.

Python Suite

SkillDescription
python-architecture-checklistPython architecture checklist executor — clean-arch boundaries, type safety, complexity, config/secrets; graded report with ruff/mypy/radon evidence.
python-security-reviewOWASP-based Python security review (FastAPI, Django, Flask) with bandit and pip-audit.
python-feature-sliceFeature-based Python architecture using FastAPI routers, Pydantic v2, and a service layer.
alembic-migration-managerFull Alembic migration lifecycle with safety checks and rollback planning.
python-modernization-analyzerLegacy Python modernization — Python 2→3, sync→async, Flask→FastAPI paths.
fastapi-scaffolderFastAPI endpoints with OpenAPI docs, Pydantic v2, JWT auth, rate limiting, and health checks.
pypi-package-scaffoldPython package scaffolding for PyPI — pyproject.toml, CI/CD, test harness, supply chain checks.

PHP Suite

SkillDescription
php-architecture-checklistPHP/Laravel architecture checklist executor — service-layer boundaries, strict typing, input validation, query safety, config/secrets; graded report with phpstan/php-cs-fixer evidence.
php-security-reviewOWASP-based PHP/Laravel security review — mass-assignment, query injection, Blade XSS, auth/session, file uploads; composer audit + psalm/phpstan; graded manager-friendly report.
php-feature-sliceFeature-based Laravel architecture — feature folders, thin controllers, Form Requests, service/action layer, API Resources, structural CQRS.
php-api-scaffolderLaravel API endpoints with API Resources, Form Request validation, Sanctum auth, throttle rate limiting, URI versioning, OpenAPI, and health checks.
php-package-scaffoldComposer package scaffolding for Packagist — composer.json, PSR-4, Pest/PHPUnit harness, GitHub Actions matrix CI, semver tag publish workflow.
php-migration-managerFull Laravel migration lifecycle — tested down(), expand-contract for zero-downtime, dangerous-operation guards, batched backfills.

Rust Suite

SkillDescription
rust-architecture-checklistRust architecture review — ownership discipline, trait design, error handling, unsafe audit, crate boundaries.
rust-security-reviewOWASP Rust security review with cargo-audit, cargo-deny, and unsafe block audit.
rust-feature-sliceVertical slice modules for Rust/Axum — router, service trait, impl, models, error types, integration tests.
sqlx-migration-managerSQLx migration lifecycle — create, review, rollback test, apply, regenerate offline cache.
rust-migration-analyzerC/C++ to Rust rewrite planning and Rust edition upgrade/modernization analysis.
axum-scaffolderProduction-ready Axum HTTP APIs with utoipa OpenAPI, JWT middleware, rate limiting, and CORS.
cargo-package-scaffoldRust crate scaffolding — Cargo.toml metadata, CI, test harness, CHANGELOG, crates.io publish workflow.

React Suite

SkillDescription
react-architecture-checklistReact architecture checklist executor — hooks discipline, effect correctness, component cohesion, state placement, render performance, type safety, accessibility; graded report with eslint/tsc evidence.
react-security-reviewOWASP-based React/TypeScript front-end security review — XSS escape hatches, bundle-secret exposure, token storage, CSP, open redirects; npm audit + eslint-plugin-security; graded manager-friendly report.
react-feature-sliceFeature-based React architecture — feature folders, presentational + container components, custom hooks, a typed data layer, and structural CQRS (query vs mutation hooks).
react-component-scaffolderSingle React component/route scaffolding — typed props, co-located RTL test, accessibility baseline, optional Storybook story.
react-app-scaffolderVite + React + TypeScript app skeleton — strict TS, Vitest + RTL, ESLint (hooks + a11y), router, error boundary, feature-folder layout.
react-modernization-analyzerLegacy React modernization — class→hooks, CRA→Vite, React 17→18→19, JS→TS, Enzyme→RTL, legacy Redux→RTK paths (assess & plan, no execution).

AI/ML Bridge Suite

SkillDescription
rag-pipeline-pythonRAG scaffold with Ollama/cloud embeddings, chunking strategies, and vector stores (Python/LangChain/LlamaIndex).
rag-pipeline-dotnetRAG with Microsoft Semantic Kernel, vector store options, and embedding models (.NET).
mcp-server-scaffoldCustom MCP server creation with FastMCP (Python), testing patterns, and protocol reference.
ollama-model-workflowLocal LLM management — Modelfile config, quantization, benchmarking.

QRSPI Workflow Suite

A structured Questions → Research → Spec → Plan → Implement loop — the instruction-budget-disciplined replacement for RPI. Correct behavior is the default through artifact gates (no magic words): each phase refuses to run until the prior artifact exists. Driven by the qrspi-orchestrator (alignment) and qrspi-implement (execution) agents, with shared read-only research-* subagents. Artifacts co-locate in thoughts/shared/qrspi/YYYY-MM-DD-{slug}/.

SkillDescription
qrspi-questionsSurfaces what the agent doesn't know as targeted technical questions; stops for human answers before research.
qrspi-researchTicket-hidden codebase research — spawns the research-* subagents in parallel, writes objective facts only (no recommendations).
qrspi-specDesign Brain-Dump → human "brain-surgery" alignment loop → vertical-slice Structure Outline.
qrspi-planConverts the spec into a vertically-sliced tactical plan; refuses horizontal-layer plans.
qrspi-implementExecutes an approved plan slice-by-slice through strict Red-Green-Refactor, checkpointing per slice.

QRASPI Workflow Suite

A structured Questions → Research → Architecture → Skeleton → Plan → Implement loop for new systems — the greenfield (V0/V1) counterpart to QRSPI. Where QRSPI maps an existing codebase and grows a feature, QRASPI maps a problem domain, locks the path-dependent decisions as MADR ADRs (with alternatives) + Mermaid C4, lands a runnable walking skeleton with fitness functions as merge-blocking CI gates, grows it slice-by-slice with Red-Green-Refactor, then graduates the result to QRSPI once real features begin. Same no-magic-words artifact gates; the Skeleton's exit gate is CI green, not a claim. Driven by the qraspi-orchestrator (no-edit Q/R/A/P/graduate) and qraspi-builder (edit Skeleton/Implement) agents. Artifacts co-locate in thoughts/shared/qraspi/YYYY-MM-DD-{slug}/; accepted ADRs live in the target repo's docs/adr/.

SkillDescription
qraspi-questionsSurfaces unknowns across the six greenfield categories (functional · quality attributes · integration · compliance · deployment · domain); stops for human answers.
qraspi-researchMaps the solution landscape (external-domain via research-synthesis, or inherited-repo via the research-* subagents) — factual, no recommendations.
qraspi-architectureLocks path-dependent decisions as MADR ADRs with ≥ 2 alternatives (align-before-lock), draws the C4 in Mermaid, and specifies the required fitness functions.
qraspi-skeletonScaffolds a runnable walking skeleton from the ADRs (one slice through every layer) and lands the fitness functions as CI gates; the exit gate is CI green.
qraspi-planConverts the next slice from the skeleton's backlog into a vertically-sliced plan-{slice}.md; refuses horizontal-layer plans.
qraspi-implementGrows the green skeleton one approved slice at a time with Red-Green-Refactor, keeping the fitness gates green; checkpoints per slice.
qraspi-graduateTerminal handoff — captures the repo + ADRs + skeleton state + fitness gates + stack into graduation.md and hands new feature work to QRSPI.
fitness-functionsAuthors architectural fitness functions and wires them into CI as merge-blocking gates (NetArchTest, import-linter, cargo-deny, Conftest). QRASPI's one new primitive.

RPI Workflow Suite (deprecated — use QRSPI)

Deprecated 2026-06-02; superseded by the QRSPI Workflow Suite above. These skills carry disable-model-invocation: true and are scheduled for removal at sunset ~2026-09-01. Listed for reference during the transition window.

A structured Research → Plan → Implement loop with parallel subagents and session isolation.

SkillDescription
rpi-researchParallel codebase exploration using subagents to gather context before planning.
rpi-planConverts a research artifact into a phased implementation plan with discrete, testable steps.
rpi-implementExecutes a phased implementation plan mechanically, one step at a time.
rpi-iterateSurgically updates an existing plan based on new discoveries or scope changes.

Requirements & Workflow Suite

SkillDescription
capture-consolidateConsolidates multiple capture documents (transcripts, emails, SOWs) into a unified requirements registry.
email-captureExtracts requirements, decisions, and action items from email threads and converts them to structured captures.
transcript-captureConverts meeting transcripts or Zoom/Slack summaries into structured capture documents.
triage-issueTriages a GitHub or Jira issue — classifies severity, identifies root cause area, recommends priority and owner.
domain-modelDDD domain modeling consultant — enforces CONTEXT.md vocabulary, surfaces code/plan contradictions, records decisions as ADRs sparingly.

Docs, Jira & Confluence

SkillDescription
jira-reviewJira ticket review with complexity scoring and requirements extraction.
jira-comment-writerPlain-language Jira comment drafter — translates technical updates into stakeholder language.
confluence-guide-writerReads Confluence spec pages and/or source code, generates well-formatted technical guides.

Agent Design & Meta

SkillDescription
skill-creatorCreates, revises, and scores SKILL.md definitions against the 5-section lean gold standard.
spec-implement (deprecated — use QRSPI/QRASPI)Converts a spec or acceptance criteria into a working implementation, test-first. Deprecated 2026-06-03; disable-model-invocation: true; removal at sunset ~2026-09-01.

Agent Support Suite (Team)

SkillDescriptionUsed By
automated-code-reviewAutonomous review checklists — security, correctness, performance, maintainability, stylecode-review-agent
test-scaffoldTest generation conventions, AAA naming, mock patterns for FreeMediator/repositoriestest-generation-agent
doc-syncDocumentation staleness detection, XML doc generation, README syncdocumentation-agent
supply-chain-auditNuGet/npm/pip vulnerability scanning, license matrix, CVE correlationdependency-audit-agent
environment-healthDocker health checks, service monitoring, container lifecycleenvironment-health-agent
research-synthesisMulti-source cross-referencing, source credibility scoring, briefing formatsresearch-agent
session-contextGit change summarization, ADR relevance matching, pattern applicabilitycontext-builder-agent
task-decompositionGoal breakdown heuristics, dependency DAGs, sub-agent assignment protocolstask-decomposition-agent

Workflow Primitives (vendored from mattpocock/skills)

Vendored copies of workflow-primitive skills from Matt Pocock's skills repo. Each carries source: mattpocock/skills in its frontmatter. See Companion Skills for the rationale and re-vendoring guidance.

SkillDescriptionUpstream path
grill-meRelentless plan/design interview — one question at a time with recommended answers.skills/productivity/grill-me/SKILL.md
zoom-outMap callers, dependents, and module relationships before continuing.skills/engineering/zoom-out/SKILL.md
cavemanTerse, keyword-driven communication mode — cuts token usage ~75%. Persistent once triggered.skills/productivity/caveman/SKILL.md
improve-codebase-architectureDeep module refactoring using APOSD vocabulary — eliminates shallow modules, information leakage, naming mismatches.skills/engineering/improve-codebase-architecture/SKILL.md
to-prdConverts context into a structured PRD with goals, user stories, and binary acceptance criteria.skills/engineering/to-prd/SKILL.md
to-issuesConverts a PRD into atomic GitHub Issues ordered by dependency.skills/engineering/to-issues/SKILL.md

skills/professional/

Coaching & Learning Suite

SkillDescription
architecture-reviewDevil's advocate critic — challenges designs via Socratic questioning against SOLID, coupling, failure modes, scalability.
pattern-tradeoff-analyzerPattern selection coach — 2-3 patterns with explicit tradeoffs; challenges golden hammer tendencies.
system-design-kataDomain-calibrated exercises (security workflows, edge fleet, hybrid cloud) with critique rubrics.
dependency-mapperCoupling visualization with Robert C. Martin metrics.
code-review-coachDeliberate review practice — user reviews first, then compares against expert analysis with category scoring.
refactor-challengerRefactoring prioritization — distinguishes aesthetic preferences from production-impact smells.
security-review-trainerProgressive security challenges — intentional vulnerabilities in clean code, scored findings.
pr-feedback-writerReview communication coach — blocking vs suggestion vs nit, constructive framing, explaining the "why".
technical-debt-assessorDebt quantification — deliberate vs accidental, cost-to-fix vs cost-to-carry, business case building.
architecture-journalLightweight ADR templates with retrospective prompts at 30/90/180 days.
spec-coachInteractive spec design coach — vision, PRD structure, INVEST story quality, specification by example, three-tier guardrails.

Edge/IoT/Robotics Suite

SkillDescription
edge-cv-pipelineOpenCV + TFLite computer vision pipeline for Jetson and Raspberry Pi with model conversion and profiling.
jetson-deployJetson Orin Nano deployment with TensorRT optimization, containerization, and power management.
sensor-integrationSensor data pipeline with I2C, SPI, UART, and GPIO. Calibration and anomaly detection.
picar-x-behaviorComposable robot behaviors for SunFounder Picar-X — subsumption architecture and behavior trees.

Agent Support Suite (Professional)

SkillDescriptionUsed By
model-optimizationQuantization workflows, TensorRT/TFLite conversion, accuracy/latency benchmarkingmodel-optimization-agent
anomaly-detectionStatistical anomaly detection, drift algorithms, alert/log/calibrate decision treessensor-anomaly-agent
fleet-managementRolling deployment strategies, multi-device coordination, rollback triggersfleet-deployment-agent

Agents

Autonomous agents that make decisions and take actions independently. Each exists in both Claude Code (claude/agents/) and OpenCode (opencode/agents/) format. Agents are split into team/ and professional/ subdirectories mirroring the skill split.

claude/agents/team/ and opencode/agents/team/ (46 agents)

Development & DevOps

AgentDescriptionSkills
tdd-agentAutonomous TDD — drives the complete RED-GREEN-REFACTOR cycle with strict guardrails.tdd, evaluate-tests
code-review-agentAutonomous code review — security, correctness, performance, maintainability, style.code-review-coach, security-review-trainer, pr-feedback-writer, automated-code-review
test-generation-agentAutonomous test generation — analyzes code, identifies gaps, generates tests with TDD patterns.tdd, test-scaffold
documentation-agentAutonomous documentation sync — detects staleness, generates XML docs, updates READMEs.architecture-journal, doc-sync
dependency-audit-agentAutonomous dependency auditing — vulnerability scanning, license compliance, upgrade paths.supply-chain-audit, technical-debt-assessor
spec-extractor-agentExtracts structured agent specs from natural-language descriptions or existing code.spec-coach
confluence-guide-writerReads Confluence spec pages and/or source code, generates formatted technical guides.confluence-guide-writer
migration-orchestratorSemi-autonomous migration orchestration — EF Core and .NET Framework migrations with approval gates.ef-migration-manager, legacy-migration-analyzer
environment-health-agentAutonomous environment health monitoring — Docker, services, connections, recovery.environment-health
task-decomposition-agentMeta-orchestrator — decomposes complex goals into sub-tasks, assigns to specialized agents.task-decomposition
pm-capture-agentConverts meeting transcripts, Slack summaries, and SOWs into structured capture documents.transcript-capture, email-capture, capture-consolidate
research-agentAutonomous research — multi-source investigation, credibility scoring, structured briefings.research-synthesis
context-builder-agentAutonomous context assembly — git change summarization, ADR matching, dependency mapping.session-context

Language & Security

AgentDescription
python-security-agentOWASP Python security review with bandit, pip-audit, and executive summary.
python-federal-security-agentFederal Python security review — NIST 800-53, FISMA, FIPS compliance.
python-modernization-agentLegacy Python modernization analysis — Python 2→3, sync→async, Flask→FastAPI.
rust-arch-checklist-agentRust architecture review — ownership, trait design, error handling, unsafe audit, Clippy.
rust-security-agentOWASP Rust security review with cargo-audit, cargo-deny, unsafe block audit.
rust-migration-agentC/C++ to Rust migration analysis and Rust modernization planning.
react-arch-checklist-agentReact architecture review — hooks discipline, effects, state placement, render perf, type safety, accessibility.
react-security-agentOWASP React/front-end security review — XSS, bundle secrets, token storage, npm audit, executive summary.
react-modernization-agentLegacy React modernization analysis — class→hooks, CRA→Vite, React 17→18→19, JS→TS, Enzyme→RTL.

Scaffolding

AgentDescription
fastapi-scaffold-agentFastAPI endpoints with OpenAPI docs, Pydantic v2, JWT auth, rate limiting, health checks.
axum-scaffold-agentProduction-ready Axum APIs with utoipa OpenAPI, JWT middleware, rate limiting.
python-feature-slice-agentFeature-based Python architecture with FastAPI routers, Pydantic v2, service layer.
rust-feature-slice-agentVertical slice modules for Rust/Axum with router, service trait, models, integration tests.
cargo-package-scaffold-agentRust crate scaffolding — Cargo.toml, CI, test harness, crates.io publish workflow.
pypi-package-agentPython package scaffolding for PyPI — pyproject.toml, CI/CD, supply chain checks.
alembic-migration-agentFull Alembic migration lifecycle with safety checks and rollback planning.
sqlx-migration-agentSQLx migration lifecycle — create, review, rollback test, apply, regenerate offline cache.
php-feature-slice-agentFeature-based Laravel architecture — feature folders, thin controllers, Form Requests, service layer, API Resources.
php-api-scaffold-agentLaravel API endpoints — API Resources, Sanctum auth, throttle rate limiting, URI versioning, OpenAPI, health checks.
php-package-agentComposer package scaffolding for Packagist — composer.json, PSR-4, matrix CI, semver tag publish workflow.
php-migration-agentFull Laravel migration lifecycle — tested down(), expand-contract, dangerous-operation guards, batched backfills.
react-feature-slice-agentFeature-based React architecture — feature folders, presentational + container components, custom hooks, typed data layer, structural CQRS.
react-component-scaffold-agentSingle React component/route — typed props, co-located RTL test, accessibility baseline, optional Storybook story.
react-app-scaffold-agentVite + React + TS app skeleton — strict TS, Vitest + RTL, ESLint (hooks + a11y), router, error boundary, feature-folder layout.

QRSPI workflow agents (qrspi-orchestrator, qrspi-implement) and the shared read-only research subagents (research-file-locator, research-code-analyzer, research-pattern-finder) are spawned automatically by the QRSPI skills/commands — not invoked directly.

QRASPI greenfield agents (qraspi-orchestrator, qraspi-builder) are spawned automatically by the QRASPI skills/commands — the orchestrator drives the no-edit Questions/Research/Architecture/Plan/Graduate phases, the builder the edit Skeleton/Implement phases. They reuse the same research-* subagents.

Deprecated RPI workflow agents (rpi-planner, rpi-implement) are superseded by the QRSPI agents above and scheduled for removal at sunset ~2026-09-01.

claude/agents/professional/ and opencode/agents/professional/ (3 agents)

AgentDescriptionSkills
model-optimization-agentAutonomous model optimization — quantization, format conversion, benchmarking for edge.model-optimization
sensor-anomaly-agentAutonomous sensor anomaly detection — statistical outliers, drift monitoring, recalibration.anomaly-detection
fleet-deployment-agentSemi-autonomous fleet deployment — canary, staged rollout, health gates, rollback.fleet-management

Commands

Twenty-two slash commands per platform. Each injects live shell state before the model acts — the model sees real output, not a description of it.

CommandInjectsWhat it does
/tdddotnet test outputRuns the TDD cycle against live failing tests
/evaluate-tests [path]—Audits existing tests: test-file quality (coupling, fragility, theater) and TDD compliance (commit-history scorecard)
/code-reviewgit diffReviews staged or branch changes
/security-review [path]—OWASP security review scoped to a path
/arch-review [component]—Socratic architecture challenge
/new-feature [FeatureName]Project structure, .csproj filesScaffolds a vertical slice feature
/migrate [MigrationName]dotnet ef migrations listEF Core migration with safety checks
/research [topic]—Multi-source research briefing
/context-primegit log, git status, git diffPrimes session from current repo state
/grill-me [plan]—Relentless one-question-at-a-time plan/design interview with recommended answers
/qrspi-questions [feature]ls of the feature folderSurfaces open technical questions; stops for human answers before research
/qrspi-research [feature]ls of the feature folderTicket-hidden parallel codebase research → objective research.md
/qrspi-spec [feature]ls of the feature folderDesign Brain-Dump → brain-surgery loop → vertical-slice Structure Outline
/qrspi-plan [feature]ls of the feature folderVertically-sliced tactical plan; refuses horizontal-layer plans
/qrspi-implement [feature]Feature folder + existing slice logsExecutes an approved plan slice-by-slice with Red-Green-Refactor
/qraspi-questions [project]ls of the qraspi project foldersSurfaces unknowns across the six greenfield categories; stops for human answers
/qraspi-research [project]ls of the qraspi project foldersMaps the solution landscape (factual, no recommendations)
/qraspi-architecture [project]ls of the qraspi project foldersLocks decisions as MADR ADRs + Mermaid C4; specifies fitness functions
/qraspi-skeleton [project]ls of the qraspi project foldersScaffolds a runnable walking skeleton with fitness-gate CI; exit gate is CI green
/qraspi-plan [project]ls of the qraspi project foldersPlans the next backlog slice; refuses horizontal-layer plans
/qraspi-implement [project]ls of the qraspi project foldersGrows the skeleton one approved slice at a time with Red-Green-Refactor
/qraspi-graduate [project]ls of the qraspi project foldersTerminal QRASPI→QRSPI handoff — writes graduation.md

Usage

/tdd                               # runs TDD cycle with live test output
/code-review                       # reviews git diff
/security-review src/              # OWASP scan scoped to src/
/arch-review OrderService          # Socratic challenge of a component
/new-feature CreateInvoice         # scaffold a vertical slice feature
/migrate AddInvoiceTable           # EF Core migration with safety checks
/research "WebSocket vs SSE"       # structured research briefing
/context-prime                     # session brief from git state

Use tdd-agent to implement a Calculator.add method
Use code-review-agent to review the latest changes
Use migration-orchestrator to plan the EF Core migration
Use research-agent to investigate WebSocket vs SSE for real-time updates

Project Templates

The project-templates/ directory contains per-project context files based on the Four Prompt Disciplines & Five Primitives framework by Nate B. Jones. Copy the relevant files into your project root — see project-templates/README.md for the full guide.

FilePurposeWhen to use
CLAUDE.md / AGENTS.mdProject context: stack, architecture, key files, boot ritualEvery project
intent.mdWhat the agent optimizes for: goals, values, tradeoff hierarchyEvery project
constraints.mdMusts, must-nots, preferences, escalation triggersEvery project
evals.mdTest cases, CI gate definitions, taste rules, rejection logEvery project
domain-memory.mdDark factory backlog and progress logMulti-session agentic work only
design.mdDesign system tokens, component hierarchy, interaction patternsUI-heavy projects only

Repository Structure

ai-toolkit/
├── skills/
│   ├── team/                   # 68 team skills (shareable, production-ready)
│   └── professional/           # 18 professional skills (deliberate practice + edge learning)
├── claude/
│   ├── agents/
│   │   ├── team/               # 46 Claude Code team agents
│   │   └── professional/       # 3 Claude Code professional agents
│   ├── commands/               # 22 slash commands with shell injection
│   └── global/                 # Global config → ~/.claude/
│       ├── CLAUDE.md           # Global instructions (every project)
│       ├── settings.json       # Hooks: credential stop + post-write build/lint gates
│       └── settings.local.json # Permissions: bash allow/deny, read allow/deny
├── opencode/
│   ├── agents/
│   │   ├── team/               # 46 OpenCode team agents
│   │   └── professional/       # 3 OpenCode professional agents
│   ├── commands/               # 22 slash commands with agent routing
│   └── global/                 # Global config → ~/.config/opencode/
│       ├── AGENTS.md           # Global instructions (every project)
│       └── opencode.json       # Providers, MCP, permissions, temperatures
├── pi/
│   └── global/                 # Global config → ~/.pi/agent/
│       ├── AGENTS-lite.md      # 7B-safe global baseline (~25 rules)
│       ├── AGENTS.md           # 20B project overlay (~50 rules)
│       ├── models.json         # Ollama provider config
│       ├── settings.json       # Compaction tuned for local context windows
│       ├── Modelfile-7b        # Modelfile template for 7B models
│       └── Modelfile-20b       # Modelfile template for 20B models
├── project-templates/          # Per-project context files — copy to your project root
├── scripts/                    # Install scripts (Bash + PowerShell)
└── docs/                       # Supplementary documentation

Author

Michael K. Alber — codeberg.org/michaelkalber

Software engineer working across enterprise .NET, Python, Rust, edge AI, robotics, and federal security domains. I build tools that encode engineering standards into AI-assisted workflows — grounding AI output in deliberate practice rather than generic defaults.

Related projects:

  • grounded-code-mcp — local RAG server that grounds AI coding agents in the books, standards, and docs you actually trust; 17 curated collections, fully local embeddings via Ollama
  • pi-packages — domain-specific Pi harnesses for local Ollama inference: hardware routing, RAG integration, context budgeting, and project-type auto-detection across six project types

License

MIT — see LICENSE for details.

Ver o original no GitHub

Bom para

Relacionados