shyamsridhar123

Define a polished CLI with Commander, chalk-styled banners, versioning, and subcommands.

Patterns from the src directory

Use to run the end-to-end assimilation phases - scan, analyze via Copilot SDK, license check, generate assets, build registry, and execute hooks.

Generate SKILL.md, agent.yaml, and hook YAML with structured content and conventions.

Validate generated skills, agents, hooks, and registry entries with actionable errors/warnings.

Run semantic analysis with the Copilot SDK to extract skills, agents, and hooks.

Normalize GitHub URLs and perform shallow clones to a temp directory with cleanup.

Load and execute YAML-defined lifecycle hooks with optional conditions and controlled timeouts.

Explore requirements and approaches through collaborative dialogue before writing a right-sized requirements document and planning implementation. Use for feature ideas, problem framing, when the user says 'let's brainstorm', or when they want to think through options before deciding what to build. Also use when a user describes a vague or ambitious feature request, asks 'what should we build', 'help me think through X', presents a problem with multiple valid solutions, or seems unsure about scope or direction — even if they don't explicitly ask to brainstorm.

Refresh stale or drifting learnings and pattern docs in docs/solutions/ by reviewing, updating, consolidating, replacing, or deleting them against the current codebase. Use after refactors, migrations, dependency upgrades, or when a retrieved learning feels outdated or wrong. Also use when reviewing docs/solutions/ for accuracy, when a recently solved problem contradicts an existing learning, when pattern docs no longer reflect current code, or when multiple docs seem to cover the same topic and might benefit from consolidation.

Document a recently solved problem to compound your team's knowledge

Generate and critically evaluate grounded improvement ideas for the current project. Use when asking what to improve, requesting idea generation, exploring surprising improvements, or wanting the AI to proactively suggest strong project directions before brainstorming one in depth. Triggers on phrases like 'what should I improve', 'give me ideas', 'ideate on this project', 'surprise me with improvements', 'what would you change', or any request for AI-generated project improvement suggestions rather than refining the user's own idea.

Transform feature descriptions or requirements into structured implementation plans grounded in repo patterns and research. Also deepen existing plans with interactive review of sub-agent findings. Use for plan creation when the user says 'plan this', 'create a plan', 'write a tech plan', 'plan the implementation', 'how should we build', 'what's the approach for', 'break this down', or when a brainstorm/requirements document is ready for technical planning. Use for plan deepening when the user says 'deepen the plan', 'deepen my plan', 'deepening pass', or uses 'deepen' in reference to a plan. Best when requirements are at least roughly defined; for exploratory or ambiguous requests, prefer ce-brainstorm first.

Structured code review using tiered persona agents, confidence-gated findings, and a merge/dedup pipeline. Use when reviewing code changes before creating a PR.

Execute work efficiently while maintaining quality and finishing features

Optimize Claude Code permissions by finding safe Bash commands from session history and auto-applying them to settings.json. Can run from any coding agent but targets Claude Code specifically. Use when experiencing permission fatigue, too many permission prompts, wanting to optimize permissions, or needing to set up allowlists. Triggers on "optimize permissions", "reduce permission prompts", "allowlist commands", "too many permission prompts", "permission fatigue", "permission setup", or complaints about clicking approve too often.

Expert guidance for integrating Azure OpenAI services into Python applications. Use when implementing LLM-powered features, chat completions, embeddings, structured output extraction, rate limiting, fallback strategies, or Azure-specific authentication. Covers both sync and async patterns.

Expert guidance for extracting text and data from PDF documents in Python. Use when implementing document ingestion pipelines, text extraction, chunking strategies, OCR for scanned documents, or metadata extraction. Covers pypdf, pdfplumber, and integration with LLM pipelines.

Expert guidance for using Pydantic V2 for data validation, serialization, and type-safe Python. Use when defining data models, validating API inputs/outputs, parsing JSON, handling LLM structured outputs, or integrating with Temporal workflows. Covers BaseModel, dataclasses, validators, and serialization.

Expert guidance for building distributed Python applications with Ray. Use when implementing parallel processing, distributed actors, remote tasks, GPU workloads, or scaling Python code across clusters. Covers Ray Core primitives, design patterns, anti-patterns, and performance optimization.

Expert guidance for combining Temporal durable workflows with Ray distributed computing. Use when building resilient parallel processing pipelines, fault-tolerant ML workflows, or systems requiring both durability AND parallelism. Covers integration patterns, error handling across both systems, and production architecture.

Expert guidance for building durable, fault-tolerant applications with Temporal. Use when implementing long-running workflows, retry logic, activity orchestration, state persistence, failure recovery, or distributed transactions. Covers Temporal Python SDK, workflow patterns, and production best practices.

Guide for implementing realistic football throw physics including impulse calculation, trajectory preview, and spin mechanics. Use this when working with ball throwing, trajectory calculation, pass physics, or spiral mechanics.

Guide for implementing adaptive quality systems and FPS monitoring for mobile browser games. Use this when optimizing performance, implementing quality scaling, monitoring frame rates, or managing battery/thermal constraints.

Guide for implementing mobile touch controls including virtual joystick and swipe-based throw mechanics. Use this when working with touch input, gesture recognition, virtual joysticks, or swipe detection.

Guide for implementing Rapier physics engine with Web Workers for off-main-thread physics simulation. Use this when working with physics simulation, rigid body dynamics, collision detection, or Web Worker threading.

Guide for implementing Theatre.js animation timeline and instant replay system. Use this when working with cutscenes, instant replays, cinematic camera animations, or timeline-based animations.

Guide for implementing Three.js WebGPU/WebGL rendering with mobile-first optimization. Use this when working with 3D rendering, WebGPU initialization, renderer configuration, or graphics performance.

Create AI agents using Microsoft Agent Framework (MAF) in Python or .NET. Use this skill when building new agents, configuring agent providers (Azure OpenAI, OpenAI, etc.), setting up chat agents, or implementing tool-calling agents.

Debug and observe AI agents using Microsoft Agent Framework DevUI and OpenTelemetry. Use this skill when troubleshooting agents, setting up distributed tracing, monitoring agent performance, analyzing agent conversations, or using the interactive DevUI.

Deploy Microsoft Agent Framework agents to production environments including Azure Functions, containers, and Azure AI Foundry. Use this skill when deploying agents to cloud platforms, containerizing agents, or integrating with Azure services.

Migrate to Microsoft Agent Framework from Semantic Kernel, AutoGen, or LangChain. Use this skill when converting existing AI agent code to Microsoft Agent Framework, understanding equivalent concepts, or porting multi-agent systems.

Build multi-agent workflows and graph-based orchestration using Microsoft Agent Framework. Use this skill when creating agent pipelines, connecting multiple agents, implementing human-in-the-loop patterns, streaming, checkpointing, or time-travel debugging.

Skill for converting between different skill formats. Use when transforming skills from anthropics/skills format to GitHub Copilot format, or vice versa. Handles SKILL.md parsing, validation, and structure transformation.

Skill for validating SKILL.md files against the GitHub Copilot Agent Skills specification. Use when checking skill structure, YAML frontmatter, naming conventions, and format compliance.

Skill for fetching and parsing content from GitHub repositories. Use when cloning repos, fetching raw files, parsing repository structure, and working with GitHub's API or raw content URLs.

Skill for working with JSONL (JSON Lines) format registries. Use when creating, querying, updating, or managing data stored in JSONL format for skill registries, logs, or datasets.

Skill for building npm CLI tools. Use when creating command-line tools with Node.js, npm packaging, argument parsing with commander or yargs, and npm publish workflows.

Build custom React code components and overrides for Framer. Use when creating Framer components, adding property controls, writing code overrides, or extending Framer functionality. Triggers on: framer component, code component, property controls, addPropertyControls, ControlType, code override, withXXX override, framer motion in framer.

Generate a Product Requirements Document (PRD) for a new feature. Use when planning a feature, starting a new project, or when asked to create a PRD. Triggers on: create a prd, write prd for, plan this feature, requirements for, spec out, product requirements, feature specification.