35 skills tagged advisory · risk axis.
Master workflow for any change touching an existing project. Walks the Aparigraha gates end-to-end — onboarding, dependency awareness, style detection, reuse-first authoring, surgical diff, post-execution audit — by orchestrating the foundation `pragmatism` philosophy and the `25-pragmatism` category skills. Contains no implementation logic.
Structured first-touch protocol for understanding an existing codebase before contributing to it. Reads the README, ADRs, most-changed and most-recent files, dependency manifests, build/CI config, and test layout, and emits an onboarding cheat-sheet other Aparigraha skills (style-conformance, reuse-first, minimal-diff, chesterton-fence) consume on subsequent tasks.
Before deleting, refactoring, or "cleaning up" code that looks unused, redundant, or weird, investigate why it exists. Produces a why-it-exists memo plus an edge-case checklist that must be confirmed before any change to the existing code is committed. Implements the Chesterton's-Fence side of Validate-Before-Trust under Aparigraha.
Perform structured code reviews with checklists, PR feedback, defect categorization, and severity classification.
The foundational constitution of the Agent Skills Garden. Every skill, every action, every line of code must honour these principles.
Analyse project dependencies — build dependency graphs, detect circular references, assess upgrade risks, and plan version migrations.
Mine the project's declared dependencies (BOM, package.json, requirements.txt, Pipfile, go.mod, Cargo.toml, etc.) and produce a curated inventory of the utilities they expose, so reuse-first and other Aparigraha skills can decide quickly without rediscovering the graph each time. Consults; never auto-rewrites.
Create and maintain a domain glossary with entities, relationships, and Protected Terms that must never be renamed.
Produce effort estimates with confidence intervals, calibrate against historical data, and communicate uncertainty clearly.
Skill discovery and routing engine. Given a user's intent (even with typos or vague phrasing), finds and loads the most relevant skill(s) from the registry using fuzzy matching and semantic search.
Parse, correlate, and analyze application logs to detect patterns, anomalies, and causal chains across distributed systems.
Generate the smallest correct change that solves the stated problem. No drive-by formatting, no opportunistic renames, no "while I'm here" expansions. Implements the Surgical-Before-Sweeping gate of Aparigraha with diff-size guardrails, scope checks, and reversibility validation.
Name scripts, tools, and files so their name tells you when and how to use them. CLI tools you run are verb-noun; imported libraries are nouns; internal helpers start with an underscore. Apply when adding or renaming any script.
Lightweight mid-task skill injection engine. Monitors task context as it evolves, detects domain shifts, and suggests loading relevant skills. Modular and non-intrusive — can be enabled or disabled independently without affecting core direction-seeking or routing.
Facilitate effective pair and mob programming sessions including role rotation, session structure, and knowledge transfer practices.
Identify performance bottlenecks through complexity analysis, profiling review, caching strategy evaluation, and resource utilization assessment.
Writes the plan.md as a fit-for-purpose agreement between user and agent. Auto-selects one of 16 named plan formats (or a 2-3 format hybrid) based on task signals — top-level, file-by-file, exact-diff, pseudocode-first, component-tree, sequence-diagram, state-machine, trace-before-patch, stats-driven-cleanup, spike, api-contract, data-migration, benchmark, multi-pr-staged, security-patch, test-coverage. Composes task-decomposition, risk-assessment, estimation, root-cause-analysis when needed. Complements Claude Code, Cursor, and Cline plan-mode harnesses — doesn't replace them.
Master workflow for a thorough PR review. Orchestrates code review, security review, and performance review in parallel, then routes the findings into PR management for triage and merge decisioning. No implementation logic.
Direction-of-thought protocol for working on real, ongoing business projects. Implements the Aparigraha pillar — non-accumulation of code, utilities, and refactors beyond what the task requires. Forces the agent to check before creating, conform within scope, stay surgical, and validate edge cases before trusting any reuse or improvement of existing code. Always loaded alongside the Constitution.
Direction-seeking protocol for AI agents. Implements the Pragya constitutional pillar — seek corrections rather than assume, present options with trade-offs, let the human steer. Embeds adaptive strategy evolution so agents pivot toward the greater good as exploration reveals new information.
Analyze application performance using profiling tools, traces, and logs to identify bottlenecks and hotspots.
Interview the user to extract goals, constraints, success metrics, and acceptance criteria before any code is written.
Monitor memory, CPU, time, and rate-limit constraints. Adapt behavior gracefully — degrade, shed load, switch algorithms. Prevents runaway resource usage and cascading failures.
Before authoring any new utility, helper, wrapper, or abstraction, scan the project's existing source and declared dependencies for an equivalent. Reuse only after fit and edge-case validation; otherwise document why nothing fit and write fresh. Implements the Check-Before-Create and Validate-Before-Trust gates of Aparigraha.
Identify project and technical risks, evaluate probability and impact, build risk matrices, and define mitigation strategies.
Systematically trace symptoms back to their underlying cause using 5-whys, fault trees, bisection, and symptom-to-cause mapping.
Defines the agent's internal monologue protocol. Before producing any output, the agent reasons privately in a scratchpad block, selects Eco or Power mode, and applies the appropriate reasoning depth.
Detect the project's existing coding conventions — naming, formatting, error handling, logging, test structure, comment style, module layout — and produce a "house style profile" that downstream skills consult when writing or modifying code. Awareness, not enforcement: the agent conforms within the scope of the change and surfaces deviations rather than auto-fixing them.
High-level system architecture: component diagrams, data flow, scalability trade-offs, and technology selection.
Break complex tasks into ordered subtasks with dependency mapping, effort estimation, and parallel execution opportunities.
Categorize, score, and prioritize technical debt with impact analysis, payoff estimation, and debt budget management.
Define the testing pyramid for a project: unit, integration, E2E. Set coverage targets and testing conventions.
Define test pyramid structure, coverage analysis, test type selection, and boundary condition identification for comprehensive quality assurance.
Optimizes agent resource consumption by selecting the right model tier, tool, delegation strategy, and parallelization pattern for each operation. Integrates with Eco/Power cognitive modes to scale resource usage proportionally to task complexity.
Decouple metric collection from pass/fail gating. Pass 1 gathers raw data. Pass 2 applies thresholds. Enables trend analysis without blocking, while still enforcing standards.