Development skills

Turn an approved specification into pseudocode, a plain outline of program logic, and an architecture defining module responsibilities and API inputs and outputs. After user confirmation, proceed with implementation and unit tests based on those designs.

• Turning an approved specification into pseudocode
• Defining module boundaries and dependency rules
• Designing API inputs, outputs, and error responses

Assess a repository's readiness for an AI agent execution framework across five dimensions. Produce JSON or a table with readiness scores, estimated cost per run, and scaffold status, without changing repository files.

• Assessing readiness before adopting an agent execution framework
• Comparing readiness scores across five dimensions
• Checking estimated run costs and scaffold readiness

Create a starter structure for a custom AI agent harness, the setup that supports agent execution. Choose a template and host, preview the plan, then explicitly confirm generation in a new directory outside the current project.

• Creating a coding agent harness from a template
• Preparing starter setups for different agent hosts
• Previewing generated files' destination before writing

Audit a TypeScript codebase organized with domain-driven design, which separates business responsibilities into distinct areas. Identify improper imports, unchecked data changes, event issues, and repository placement problems, then report their locations and suggested fixes.

• Auditing dependencies between business domains
• Reviewing cross-module changes before merging
• Checking domain boundaries in continuous integration

Compare two JSON records describing agent setups and their scores. Receive an overall similarity score with component details to help assess reuse, compare template candidates, identify overlapping work, or check how much a setup has changed.

• Deciding whether to reuse an existing agent setup
• Ranking template candidates for a target repository
• Finding duplicate work across teams

Create TypeScript scaffolding for a domain aggregate, a group of objects governed by shared business rules. Generate its main entity, value objects, repository interface, domain events, and unit test stubs inside an existing context.

• Adding an aggregate to an existing domain context
• Modeling a business concept with rules to enforce
• Creating entity, repository, event, and test scaffolding

Create a standard folder layout for a DDD bounded context, a module organized around one business area. Generate TypeScript export files, keep infrastructure outside the public exports, and record the context in a domain model graph.

• Starting a module for a new business area
• Splitting a monolith into bounded contexts
• Listing existing contexts

Analyze Git changes before submitting or merging a pull request. Assess risk and complexity, classify changes, suggest reviewer roles, and identify files needing closer inspection using diff statistics and file-level risk analysis.

• Assess change risks before submitting a pull request
• Review large changes spanning multiple modules
• Identify reviewer roles suited to the changes

Assess a repository without changing it and report its type, suggested agent roles, risk, MCP connections, test confidence, and publication readiness. Use the results for setup decisions, comparisons over time, or automated risk checks in CI.

• Reviewing a repository before creating a custom agent harness
• Comparing reports over time to spot architecture drift
• Failing a CI build when risk exceeds a chosen threshold

Run Ruflo background workers on a recurring schedule within a Claude Code session. Choose tasks such as security analysis, documentation, or test coverage analysis, check their status, and stop the loop after repeated reports of no new work.

• Run recurring security analysis
• Periodically check test coverage gaps
• Repeat code analysis and documentation tasks

Extract classes, functions, modules, and their relationships from source code or documentation into AgentDB. Build a knowledge graph, a map of connected entities, to understand code structure, dependencies, and potential change impacts.

• Understanding a codebase's structure
• Investigating dependencies between modules
• Assessing the impact of code changes

Create paired SQL files for applying and reversing database structure changes. Determine the next sequence number from existing migrations, choose a template based on the change name, and record metadata with the migration marked as pending.

• Prepare SQL files for creating a table
• Create paired migrations for adding a column
• Prepare a migration to add an index

Explore a knowledge graph, a network of entities and relationships, from a chosen starting point. Rank relevant paths and summarize dependencies or indirect connections to help understand code structure and assess the impact of changes.

• Assessing the impact of changing a component
• Tracing dependency chains
• Discovering indirect connections between entities

Manage Git branches, resolve conflicts, and coordinate pull requests, which propose code changes. Check change risks and automated test status before merging, and inspect metrics such as merge frequency and review time.

• Create a feature branch and prepare a pull request
• Collect fixes into a release branch
• Check change risks before merging

Set up Ruflo in a new repository using an interactive wizard or the standard preset. Create project instructions and configuration files, including MCP server registration so the agent can access the ruflo tools.

• Introduce Ruflo into a new repository
• Set up a project with an interactive wizard
• Initialize configuration using the standard preset

Apply simple code changes across files without calling an LLM, using agent-booster's local transformation engine. The skill checks a confidence score before saving results and records outcomes for cost tracking and future routing decisions.

• Apply repetitive code changes across many files
• Remove console statements
• Run repeatable code transformations in CI

Automate checks, code formatting, agent coordination, and session records around Claude Code operations. Uses hooks, actions triggered before or after work, to preserve context and connect development tasks with shared memory.

• Automatically format and validate edited code
• Share progress across multiple agents
• Save and restore development sessions

Restructure claude-flow v3 into focused modules using Domain-Driven Design, which groups code by responsibility. Define module boundaries, event communication, and plugin interfaces to support a modular architecture with independently testable business logic.

• Split an oversized orchestrator into focused modules
• Define boundaries between tasks, sessions, and monitoring
• Design plugin extensions and domain events

Build a searchable index and relationship graph from ADRs, records of architectural decisions. Import two supported document formats, refresh existing metadata without duplicate relationships, and review summaries of statuses, missing references, and inconsistencies.

• Index ADRs imported from another project
• Refresh a graph that differs from files on disk
• Set up ADR tracking in an existing codebase

Measure and optimize claude-flow v3 startup, search, attention processing, and memory use. Compare benchmarks against performance targets, track changes over time, and identify regressions to guide further optimization.

• Compare performance before and after v3 optimization
• Evaluate vector search speed and memory use
• Track performance regressions over time

Find prebuilt WASM agents, software components packaged in WebAssembly format, through gallery browsing and keyword search. Install agents from their configurations, or export and publish your own agents to share with the community.

• Browse available community agents
• Find agents by keyword
• Install a prebuilt agent

Refactor claude-flow into an extension of agentic-flow@alpha to reduce duplicate implementations. Plan adapter layers, migrate agent and task management, and connect learning, shared memory, and tools while checking compatibility with existing functionality.

• Consolidate duplicate agent and task management code
• Design an adapter that preserves existing APIs
• Integrate learning, shared memory, and MCP tools

Coordinate specialized AI agents under a lead coordinator for research, development, and review. Configure voting rules, share persistent knowledge, assign tasks, monitor progress, and pause or resume sessions through Claude Flow.

• Divide application development among specialized agents
• Research and compare GraphQL and REST
• Coordinate reviewers for a pull request

Implement core TypeScript modules for claude-flow v3 using domain-driven design, which organizes code around distinct responsibilities. Build task and session domains, connect storage and services, and add unit and integration tests.

• Build the core structure for claude-flow v3
• Implement task assignment and status rules
• Connect SQLite storage through dependency injection