github/awesome-copilot
301 skills2M installs10M starsGitHub
Install
npx skills add https://github.com/github/awesome-copilotSkills in this repo
1Git CommitGit Commit is an agent skill that executes git commits using the Conventional Commits specification, analyzing your real diff to propose type, optional scope, and description instead of generic messages. Solo builders using Claude Code, Cursor, or similar tools invoke it whenever they want standardized history—during feature work, bug fixes, documentation passes, CI tweaks, or chore maintenance—without manually parsing changed files. The skill supports automatic detection from the patch, interactive refinement when you want a specific scope, and intelligent staging so unrelated edits can be split into separate semantic commits. It is explicitly allowed to run Bash for git operations, which matches how agents actually land work in a repository. Breaking-change footers and optional body text follow the same spec agents and humans expect on GitHub. It is not a substitute for code review or release automation; it shortens the loop from “done editing” to “clean commit on main or feature branch.” Use it across build, ship, and operate whenever you need consistent messages for changelogs and semantic versioning.33.6kinstalls2Excalidraw Diagram GeneratorExcalidraw Diagram Generator is an agent skill that converts plain-English requests into Excalidraw-compatible JSON files so solo builders can visualize workflows, system boundaries, and ideas without hand-drawing. It fits indie founders who need a quick architecture sketch for a PRD, a validation flowchart for a landing funnel, or a mind map while researching competitors—then drop the file into docs or Notion-linked design folders. Supported diagram families include sequential flowcharts, entity relationship views, mind maps, system architecture, data-flow diagrams, and cross-functional swimlanes. Invoke when someone asks to create a diagram, make a flowchart, draw system architecture, or generate an Excalidraw file. The deliverable is an import-ready .excalidraw asset, not a rendered PNG unless you export separately in Excalidraw.22.6kinstalls3Gh Cligh-cli turns GitHub’s command-line tool into an agent-ready playbook for solo builders who live in the terminal. It documents installation on major platforms, authentication patterns for GitHub.com and enterprise hosts, and git integration so pushes and pulls reuse gh credentials safely. Beyond auth, the skill’s scope is intentionally broad: repositories, issues, pull requests, GitHub Actions, projects, releases, gists, codespaces, organizations, and extensions—matching how an indie operator runs the whole GitHub surface without context-switching to the browser. Use it when you need exact subcommands for creating PRs, triaging issues, inspecting workflow runs, or scripting release steps in Ship and Launch prep. The reference style suits intermediate users who know git basics but want authoritative gh syntax in one place. It complements code-review skills on the human side and CI skills on the automation side, while staying a integration-oriented cheat sheet rather than a replacement for GitHub’s online docs.21.5kinstalls4Documentation WriterDocumentation Writer is an agent skill that acts as a Diátaxis documentation expert for solo and indie builders shipping software with AI coding agents. It steers you away from generic wiki dumps toward four intentional document types: tutorials that onboard newcomers, how-to guides that solve one problem, reference that describes machinery precisely, and explanations that deepen understanding. The skill encodes clarity, accuracy, user-centricity, and consistency as non-negotiable rules so snippets and behavior descriptions stay trustworthy. Use it when you are starting a docs site, refactoring README chaos, or splitting one overloaded page into the right quadrant. It fits Claude Code, Cursor, and similar agents because it is procedural editorial judgment packaged as repeatable workflow, not a one-shot summary. Confidence is high for teams that already commit to Diátaxis; you still own product facts and review for your stack.19.5kinstalls5Prdprd is a GitHub Awesome Copilot skill for solo founders and indie teams who need a production-grade Product Requirements Document instead of scattered notes in chat. It treats requirement writing as a gated workflow: Phase 1 interrogates the core problem, success metrics, budget, stack, and deadlines before any template filler runs. Phase 2 synthesizes input into user flows, dependencies, and non-goals that keep agents from over-building. Phase 3 drafts the full PRD structure so engineers and coding agents share one scope artifact. It fits AI features and conventional SaaS equally. Use it when kicking off a feature cycle, when stakeholders need alignment, or when you say write a PRD or plan a feature. The skill is process-heavy rather than a one-shot generator, which makes it especially valuable for builders who ship with Claude Code or Cursor and want specs that downstream implementation skills can follow.19.1kinstalls6RefactorRefactor is an agent skill for solo builders who need to clean up working code without betting the product on a rewrite. It teaches surgical, behavior-preserving changes: extract functions, rename for clarity, shrink god functions, tighten types, and address code smells with recognizable design patterns. The skill stresses discipline—commit often, test after each micro-step, and never blend refactors with new features in the same pass. It also states plainly when to stop: untested critical paths, immovable deadlines, or code that will never change again. That framing helps agents avoid destructive “cleanup” sessions that silently change semantics. Use it when a user says refactor this module, the structure makes every feature painful, or a review notes unreadable nesting. It is intentionally gentler than repo-rebuilder-style overhauls. You still need tests for confidence; without them the skill treats the work as editing, not refactoring. Outcome is code that is easier to extend and review while outward behavior stays the same.17.8kinstalls7Java SpringbootJava Spring Boot is a concise agent skill from GitHub’s awesome-copilot collection that steers solo builders toward maintainable Spring Boot applications. It encodes opinionated setup guidance: pick Maven or Gradle, lean on official starters, organize code by feature domain rather than technical layer, and wire components with constructor injection and clear stereotype annotations. Configuration sections promote readable application.yml, typed property objects, and profiles so indie teams can run dev and prod without scattering magic strings. The skill does not replace Spring reference docs; it gives coding agents a checklist to apply during greenfield services and refactors so REST APIs, JPA modules, and service layers stay consistent. Install it when you want Copilot-, Cursor-, or Claude-driven Java changes to respect Spring idioms instead of generating layered spaghetti or field injection defaults.16kinstalls8Multi Stage DockerfileMulti-stage-dockerfile is an agent skill that walks solo and indie builders through production-style Dockerfiles for any language or framework. It enforces a builder stage for compile-time work and a slim runtime stage that copies only runnable artifacts, which cuts image size and shrinks the attack surface compared to single-stage builds. You get concrete rules for base image selection, reproducible version pins, layer ordering for Docker cache, and when Alpine or distroless runtimes make sense. The skill fits the Ship phase when you are containerizing an API, SaaS backend, or CLI service for the first real deploy and do not want to guess Dockerfile structure from blog posts. It is procedural guidance your coding agent applies while drafting or refactoring a Dockerfile and related ignore files, not a hosted build service.14.7kinstalls9Create ReadmeCreate README is an agent skill from GitHub’s awesome-copilot collection that turns your entire project context into a credible open-source README.md. It positions the agent as a senior engineer who prioritizes clarity, scannability, and restrained emoji use rather than marketing fluff. The workflow starts with a deliberate review of the workspace, then shapes sections using battle-tested public READMEs from Azure serverless samples and similar repos as structural guides. Output is GitHub Flavored Markdown, including community admonition syntax when warnings or tips help onboarding. Solo builders reach for this when a repo is functionally ready but GitHub still shows a blank or outdated front door—common right before first commit publicity, a launch post, or onboarding a collaborator. The skill deliberately avoids duplicating legal and contribution docs that already live elsewhere. It does not run Indexion or doc.json pipelines; it is a single-shot authoring pass optimized for human readers landing on the default branch.13.7kinstalls10Playwright Generate TestPlaywright Generate Test is an agent skill for solo builders who want reliable browser tests without hand-transcribing every click from a scenario. You describe a user journey (or the skill prompts you for one), then the agent runs each step live through Playwright MCP—no premature TypeScript until the flow is proven. After the walkthrough, it writes a Playwright test file, places it in your tests folder, executes it, and fixes issues until the run passes. It fits SaaS and web products where E2E coverage is the gate before ship, and pairs naturally with Cursor or Claude Code when you already use MCP for browser automation. Use it when you have a flow in words but not in code, or when brittle one-shot test generation has failed you before.13kinstalls11Conventional CommitConventional Commit is a multi-phase agent skill that walks you from unstaged changes to a spec-compliant git commit using a structured XML prompt template. Solo builders use it whenever they want readable history, automated changelog-friendly types, and less bike-shedding over message wording. The workflow inspects git status and diffs, stages files, composes type(scope): description with optional body and footer, then executes git commit in the terminal without extra confirmation. It fits indie shipping rhythms: small frequent commits during Build, pre-PR polish in Ship, and disciplined fixes in Operate. The skill is procedural knowledge for Copilot-style agents—not a linter replacement—so you still choose scope and breaking-change footers thoughtfully.12.6kinstalls12Chrome Devtoolschrome-devtools is an expert agent skill that connects your coding assistant to the Chrome DevTools MCP server for real-browser control. Indie founders shipping solo often lack a dedicated QA bench; this skill lets one agent open tabs, exercise flows, capture screenshots for tickets, read console and network failures, and record performance traces when a landing page feels slow. It spans more than a single click-helper: categories cover navigation, interaction, inspection, profiling, and emulation so you can resize viewports or throttle CPU/network while debugging. Reach for it when tasks sound like “log in and screenshot the dashboard,” “why is this fetch failing,” or “profile LCP on staging.” It assumes MCP wiring rather than a prompt-only CLI, so setup sits with your agent tooling in Build but payoff clusters in Ship and Operate. Pair it with your frontend stack when validating extensions, marketing sites, or full SaaS UIs. Advanced users get structured tool names aligned to DevTools capabilities; beginners should budget time to connect the MCP server once.12.4kinstalls13Postgresql OptimizationPostgreSQL Optimization is an agent skill for developers who treat Postgres as the primary datastore and want expert, dialect-specific guidance instead of generic relational snippets. It activates on selected SQL or whole-project database work, emphasizing features only Postgres offers well: JSONB with GIN indexing and rich operators, first-class array columns and set operations, custom and range types, geometric types where relevant, full-text search, window analytics, and sensible use of the extensions ecosystem. Solo builders shipping SaaS or API backends use it while designing event tables, tagging models, admin filters, and reporting queries that would be awkward in other engines. The embedded examples show index choices, containment filters, and aggregations that performance-tune real paths. It is not a hosted DBA service or migration runner—you still own backups, capacity, and security reviews. Revisit during Operate when slow queries appear, but first invocation usually happens while implementing backend data models in Build.12.3kinstalls14Memory MergerMemory Merger is an agent skill for solo builders who use GitHub Copilot-style domain memory and instruction files and need a disciplined way to promote stable lessons without copy-paste drift. You invoke it with `/memory-merger >domain-name [scope]`, choose global or workspace storage, and the skill walks through consolidating mature entries from the memory file into the instruction file while preserving knowledge and trimming overlap. It is built for operators and agent tinkerers who iterate on coding agents across projects: global scope applies user-wide prompts, while workspace scope limits changes to the current repo’s instruction set. The workflow emphasizes transparency via an explicit todo list so you can see what was merged, what was deduplicated, and what still belongs only in short-term memory. Use it when a domain file has outgrown ephemeral notes and should become durable guidance your agent loads every session.12.2kinstalls15Sql Optimizationsql-optimization is an agent skill that acts as a database performance coach for solo builders shipping data-backed SaaS or APIs. It applies to selected SQL in the editor or the whole project when no selection exists, and organizes work around query performance analysis, indexing discipline, pagination fixes, and batch operations that scale across engines. The skill contrasts anti-patterns—functions on indexed columns, SELECT *, correlated subqueries—with rewrite patterns, JOIN strategies, and concrete CREATE INDEX suggestions you can adapt per dialect. It is meant for intermediate builders who can run EXPLAIN or vendor equivalents and iterate on plans before users feel latency in production. Use during ship perf hardening, when refactoring hot paths in build, or when operating on slow reports—without replacing a full DBA engagement for exotic workloads.12.1kinstalls16Github Issuesgithub-issues teaches an agent how to manage GitHub Issues and Projects through the Model Context Protocol GitHub server plus REST/CLI for operations MCP does not expose. Solo builders use it to turn chat intent into structured work: filing bugs, feature requests, and chores; updating titles and bodies; setting labels, assignees, and milestones; and syncing GitHub Projects fields such as priority, start dates, and status columns. Read-heavy discovery—listing, searching, and pulling comments or sub-issues—stays on MCP tools, while creates and updates follow the documented CLI/REST path so the skill matches real server capabilities. It also covers linking issues and expressing dependencies when work is blocked. Best when you already use GitHub as source of truth and want your coding agent to maintain the board without leaving the repo context.12kinstalls17Dotnet Best Practicesdotnet-best-practices is an agent skill that reviews or guides changes in a chosen .NET/C# selection so it matches project-specific conventions, not generic lint rules. Solo and indie builders shipping ASP.NET APIs, worker services, or desktop shells use it when an agent refactors handlers, adds services, or expands public surface area without drifting from established architecture. The skill spans documentation and structure (XML comments and namespace layout), design patterns (primary constructors, generic command handlers, factories), dependency injection lifetimes and testable interfaces, and localized resources via ResourceManager. It fits multi-phase workflows: during Build while implementing features, and during Ship when tightening review before merge. Confidence is high for Copilot-style “selection” workflows because the readme anchors behavior to ${selection} and named Microsoft patterns rather than vague style advice.12kinstalls18Microsoft DocsMicrosoft Docs is a research-oriented agent skill for the full Microsoft technology stack—Azure, .NET, M365, Power Platform, Agent Framework, Semantic Kernel, Windows, and related repos whose docs live outside learn.microsoft.com. Solo builders use it whenever an implementation decision should cite official guidance instead of model recall. The default workflow routes queries through Microsoft Learn MCP search, targeted code-sample search, and full-page fetch; VS Code, GitHub, Aspire, and Agent Framework material can be reached through Context7 and Aspire MCP when Learn does not host the content. A documented `mslearn` CLI offers a shell fallback if MCP is not wired in the IDE. The skill fits early Validate scoping, deep Build integration work, Ship-time security and configuration reviews, and Operate tasks where you need current Azure or monitoring docs. It does not replace running tests or applying IaC— it grounds the agent in verifiable Microsoft documentation before you commit to patterns.11.7kinstalls19Create Specificationcreate-specification is a GitHub Awesome Copilot skill that turns vague build intent into a single, parser-friendly specification file agents can execute against. Solo builders use it when a feature touches multiple components—schemas, tools, data contracts, infrastructure, process, architecture, or design—and need one authoritative document instead of scattered chat threads. The skill encodes documentation discipline: precise language, acronym definitions, edge-case examples, and clear separation of must-haves from recommendations. Output lands in the repository `/spec/` directory following a predictable `spec-*.md` naming scheme so downstream coding agents can glob and load the right file. It pairs naturally with planning and implementation skills in a Copilot stack: once the spec exists, implementation becomes constrained generation rather than guesswork. Intermediate complexity reflects judgment calls on scope boundaries and interface completeness. Best for agent-forward repos; skip when you only need informal README notes or already maintain OpenAPI-only contracts with no behavioral requirements.11.5kinstalls20Microsoft Code Referencemicrosoft-code-reference routes coding agents to authoritative Microsoft Learn sources when implementing Azure SDKs, .NET libraries, and other Microsoft APIs. It prescribes a compact tool table: search docs for classes and methods, fetch full reference pages when overloads matter, and pull language-specific code samples before drafting implementation or debugging failures. Solo builders on Copilot-style stacks avoid the classic agent failure modes—nonexistent `UploadAsync` variants, mismanaged identity snippets, or deprecated Service Bus APIs—by comparing agent output to samples returned from `microsoft_code_sample_search`. The skill expects the Microsoft Learn MCP Server when available and notes an mslearn CLI fallback, which matters for air-gapped or MCP-less setups. Use it during Build integrations, during Ship review of cloud-touching PRs, or when Operate incidents need verified SDK usage rather than forum guesses.11.4kinstalls21Nuget Managernuget-manager keeps NuGet changes in .NET repos predictable for solo builders maintaining APIs, worker services, or full solutions. When you need a new dependency, a removal, or a security-driven version bump, the skill forces the right tool: CLI for add/remove, controlled edits only for version strings, then an immediate restore to prove the graph resolves. It accounts for both classic per-project PackageReference entries and central versioning in Directory.Packages.props, and expects you to confirm the target version exists on nuget.org before typing it in. Prerequisites are a compatible .NET SDK on PATH and jq or PowerShell for search-based verification. The outcome is fewer broken CI builds from sloppy csproj surgery and a repeatable habit—add with dotnet, bump with evidence, restore before you move on to tests or deploy scripts.11.3kinstalls22Web Design Reviewerweb-design-reviewer is a visual QA skill for websites that are actually running. When you say “review website design,” “check the UI,” or “fix the layout,” the agent gathers context, drives a browser to capture how pages look and behave, diagnoses responsive, accessibility, consistency, and breakage problems, edits frontend source in the workspace, and re-runs inspection until issues clear or you stop the loop. It applies across common stacks—from hand-rolled HTML/CSS through framework SPAs and headless CMS themes—so solo builders shipping landing pages, dashboards, or marketing sites do not rely on guesswork in chat alone. Prerequisites are explicit: a reachable dev or staging URL (production allowed for read-only review), working screenshot/navigation automation, and repo access when fixes are in scope. Use it in Build while iterating layouts, and again in Ship before launch when polish and WCAG-style concerns matter.11.3kinstalls23Refactor PlanRefactor Plan is a planning skill for solo builders about to touch many files at once. It forces the agent to search and read the real codebase—implementation, tests, config, and docs—then document current state, target state, coupling risks, and a phased change order before any edit lands. That sequence favors types and contracts first, then implementations and callers, then tests and cleanup, with verification hooks and rollback notes on the riskiest phases. If the request is ambiguous, the agent asks concise clarifiers instead of guessing. The default workflow ends at a complete plan and waits for your go-ahead, which prevents half-baked refactors from steamrolling a small repo. Use it when renaming modules, extracting services, migrating patterns, or untangling dependencies across a codebase you ship yourself.11.1kinstalls24Sql Code ReviewSQL Code Review is an agent skill from awesome-copilot that runs a structured pass over your SQL selection or project for security, performance, maintainability, and database best practices. Solo builders shipping SaaS APIs or internal tools use it when hand-written queries, migrations, or ORM-adjacent SQL need a second opinion before merge or deploy. The skill emphasizes SQL injection prevention with parameterized patterns, principle-of-least-privilege access, schema and DEFINER/INVOKER review, and reducing sensitive data exposure. It is positioned to complement a separate SQL optimization prompt so you can cover correctness and safety first, then tune performance. Install it when you are not confident your agent will catch dynamic string concatenation, overly broad grants, or review-section anti-patterns on its own.11.1kinstalls25Javascript Typescript Jestjavascript-typescript-jest is an agent skill that encodes Jest best practices for solo builders shipping JavaScript or TypeScript apps with Claude Code, Cursor, or similar tools. It steers the agent toward descriptive test names, isolated mocks for APIs and databases, and reliable async handling so flaky suites do not block Ship. The guidance spans plain Node logic, promise-based code, snapshot checks for stable UI, and React components tested through user-visible behavior rather than implementation details. Use it whenever you ask an agent to add coverage, fix failing specs, or align a brownfield repo with Testing Library conventions. It matters because ad-hoc test prompts produce inconsistent mock hygiene and skipped accessibility queries; this skill keeps outputs reviewable and CI-friendly without replacing your own assertions about business rules.11kinstalls26Create Implementation Plancreate-implementation-plan is an agent skill for solo builders who want implementation plans that other agents—or future you—can run without re-negotiating intent in chat. It forces deterministic language, self-contained phases, and executable tasks with explicit paths and symbols, which fits Validate when you are locking scope and Build when you are breaking PM work into agent-sized chunks. The skill treats plans as AI-to-AI artifacts: no ambiguous hand-waving, optional parallel work inside phases, and declared cross-phase dependencies only when necessary. Use it when starting a feature, planning a refactor, or documenting an infra migration so execution does not depend on memory of an old thread. It reduces rework for indie teams where one person both specs and ships, and pairs naturally with repository context skills once the plan file exists on disk.10.9kinstalls27Create Agentsmdcreate-agentsmd is an agent skill that drafts a complete AGENTS.md for your repository so solo builders do not manually reverse-engineer what every coding agent needs to know. It follows the public agents.md format: standardized root placement, Markdown structure, and sections for setup, architecture, and conventions that would clutter a human README. The skill is especially valuable when you onboard Cursor, Claude Code, or Windsurf onto an existing codebase and want predictable instructions instead of repeating rules in each chat. It sits in Build as agent-tooling but pays off across Ship and Operate whenever new contributors—or agents—touch the repo. For indie products where you are both author and operator, a solid AGENTS.md reduces wrong-package-manager commands, missed test scripts, and inconsistent style across sessions.10.9kinstalls28Playwright Explore WebsitePlaywright Explore Website is an agent skill that drives structured manual-style discovery of a web application through the Playwright MCP server. Solo and indie builders ship browser products constantly but rarely have time to reverse-engineer every critical path before automating tests; this skill turns a single URL into a focused tour of three to five core flows, with written notes on what was clicked, which selectors matter, and what should happen next. It fits the Ship phase when you are expanding coverage, validating a staging build, or onboarding an agent to a unfamiliar UI without dumping the whole sitemap into context. The workflow intentionally ends by proposing concrete test cases, so exploration is never a dead-end report. You need MCP-backed browser control and a target environment; it is less suited when you already maintain a full Playwright suite or only need API-level checks.10.9kinstalls29Webapp TestingWebapp Testing is a compact helper module for Playwright-based web application tests, aimed at solo builders who paste pragmatic utilities into specs instead of maintaining a large internal framework. The exports center on three recurring pain points: waiting for async UI state without arbitrary sleeps, collecting browser console output when a test fails in CI, and grabbing full-page screenshots with consistent naming for postmortems. It sits in the Ship phase when you are hardening E2E or debugging intermittent failures on a SaaS or internal admin UI. The skill is code-first rather than a conversational ritual—your agent imports or copies the functions into existing Playwright projects. It assumes Node-style module usage and a Page object from Playwright; it does not replace exploration skills or MCP-driven browsing when you still need to discover selectors from scratch.10.9kinstalls30Azure Devops CliAzure DevOps CLI is a reference-oriented agent skill for solo builders who already use the Azure CLI to drive DevOps from the shell or from an coding agent. It focuses on the advanced surface area that SKILL.md emphasizes: choosing output formats for humans versus scripts, composing JMESPath queries to filter pipelines and runs, and applying global flags consistently across commands. Use it when you need repeatable, copy-pasteable patterns instead of ad-hoc `az` exploration—especially while debugging a failed run, auditing which pipelines are enabled, or wiring CI metadata into a deploy checklist. The material assumes Azure DevOps is your system of record for builds and releases; it does not replace portal workflows but makes terminal-first automation reliable. Intermediate familiarity with Azure login, subscriptions, and project scope is expected.10.9kinstalls31Pytest Coveragepytest-coverage is an agent skill for solo Python builders who want every line exercised before they ship. It standardizes a tight loop: generate an annotate coverage report with pytest --cov, open matching files under cov_annotate when coverage is below 100%, treat exclamation-marked lines as gaps, and add tests until those lines disappear. You can narrow scope to one module or one test file when fixing a hot spot instead of re-running the whole suite blindly. The skill assumes pytest and pytest-cov are already in your project and that your goal is full line coverage rather than a arbitrary percentage threshold. It fits backend services, CLIs, and libraries where regressions hide in rarely hit branches. Use it when an agent is asked to improve or verify test coverage, not when you only need a one-off smoke test without measurement.10.8kinstalls32Penpot Uiux Designpenpot-uiux-design is a comprehensive agent skill for solo builders who prototype in open-source Penpot instead of a closed design SaaS. It maps common product asks—new screens, dashboards, forms, navigation, landing pages, and component libraries—to MCP workflows: run JavaScript in the Penpot plugin context, export PNG or SVG for visual check, import assets, and pull API docs when needed. The skill emphasizes user-centered patterns, accessibility standards, and platform-specific guidance so agents do not only draw boxes but align with iOS, Android, and Material expectations. Canonical shelf is Validate → prototype when you are proving layout and flow; it stays relevant in Build → frontend when you translate specs into hi-fi UI. You need the penpot-mcp server running locally; troubleshooting lives in the bundled setup reference. Use when triggers like create interface, build layout, or make it accessible appear in the task.10.7kinstalls33Typescript Mcp Server GeneratorTypeScript MCP Server Generator is an agent skill for solo builders who want a custom Model Context Protocol server without reverse-engineering the SDK from scattered docs. It specifies end-to-end project creation: npm init, dependencies, ES module TypeScript config, McpServer bootstrap, and either Streamable HTTP on Express or stdio transport for local agent clients. Zod validates tool inputs, and the skill mandates at least one real tool plus structured error handling so the result is runnable—not a stub. Use it in Build when you need agents to call your API, database, or internal scripts through a standard MCP surface. Outputs align with Claude Code and Cursor expectations for installable MCP packages, setting you up for Ship-phase security review and Launch documentation of what each tool exposes.10.5kinstalls34Architecture Blueprint GeneratorArchitecture Blueprint Generator is an agent skill for solo builders and small teams who already have code and need durable architectural memory. It analyzes the repository, infers stacks and patterns, and emits a comprehensive Project_Architecture_Blueprint.md that captures layers, boundaries, integration style, and how new features should extend the system without drift. Detail level scales from executive overview to implementation-ready notes, with toggles for diagrams, code exemplars, implementation patterns, and architectural decision records. It supports common stacks such as .NET, Java, React, Angular, Python, Node.js, and Flutter, and patterns from monoliths to event-driven and serverless shapes. Use it when onboarding yourself after a hiatus, preparing refactors, or standardizing how agents and contributors should add modules— not when you are still at napkin-stage with no repository to inspect.10.5kinstalls35Postgresql Code ReviewPostgreSQL Code Review is an agent skill for solo builders and small teams who store critical data in Postgres and want reviews that generic SQL linters miss. It focuses on JSONB query patterns that can use GIN indexes, array operations, custom types, schema constraints, and function performance, with explicit bad-and-good examples your agent can apply to the current selection or the full repo. Row Level Security and other Postgres-only security surfaces are in scope so ship-ready APIs do not leak rows across tenants. Use it during Ship before merging database migrations, after substantial schema changes, and in Operate when hardening production queries. It is a checker-style procedural skill—not a migration generator—meant to complement your test suite and ORM layers by catching index-hostile filters and fragile JSON mutations early.10.5kinstalls36Game EngineGame Engine is a 2D maze game template modeled on MDN Phaser device-orientation tutorials and the Cyber Orb demo. Solo builders get a working Phaser 2.x project layout—Boot through Game scenes, sprite assets, horizontal and vertical wall segments, and win condition at the top hole. Mobile players tilt to roll the orb; desktop users use arrows. The skill encodes collision feedback, level progression, and timing so an agent can extend levels, reskin art, or adapt mechanics without scaffolding from zero. It targets indie prototypes and learning projects rather than production multiplayer backends.10.2kinstalls37Java Junitjava-junit is an agent skill that teaches JUnit 5+ best practices for solo and indie builders shipping JVM backends. It walks through standard Maven or Gradle project layout, placing tests under src/test/java with the Jupiter API, engine, and params artifacts on the classpath. The skill emphasizes one-behavior-per-test, independence, idempotency, and descriptive naming conventions paired with lifecycle hooks for setup and teardown. Parameterized and data-driven coverage is included so agents can generate @ParameterizedTest methods with appropriate value and method sources instead of copy-pasting nearly identical cases. Use it when you want consistent test class naming, readable @DisplayName labels, and repeatable local runs without ad-hoc JUnit 4 patterns mixed into a modern stack.10.1kinstalls38Playwright Automation Fill In Formplaywright-automation-fill-in-form is a narrow Playwright MCP playbook for automating multi-field web forms without accidentally submitting production data. The skill directs the agent to open a specified forms URL, populate show title, date, time, topic, and an image path, then stop and ask for human review because submission is forbidden in the instructions. That guardrail makes it useful for solo builders rehearsing event registrations, internal surveys, or launch signups where a mistaken click would send partial or test data. Adapt the URL and field map for your own target while keeping the review gate. Pair it with a Playwright MCP server configured in your agent environment so browser actions run outside pure chat hallucination.10.1kinstalls39Dotnet Design Pattern Reviewdotnet-design-pattern-review is an agent skill for solo and indie builders shipping C#/.NET solutions who want a structured, non-destructive critique of design-pattern usage in a code selection. It walks through six mandated patterns—Command handlers with generic bases and host setup, Factory creation with the service provider, constructor-based DI with explicit null checks and lifetimes, async Repository abstractions, Provider contracts for external systems, and ResourceManager-backed localization—and flags gaps or misapplications. A second pass covers solution architecture (Core versus Console namespaces, modularity) and contemporary .NET style. Use it when you are about to open a PR, after a large refactor, or when onboarding an agent to your house style. The output is narrative guidance only, which keeps diffs under your control while still aligning agents and humans on the same pattern vocabulary.10.1kinstalls40Review And Refactorreview-and-refactor packages a disciplined housekeeping loop for repositories that already encode standards in GitHub Copilot instruction markdown. The agent adopts a senior maintainer stance, ingests every file under `.github/instructions/` plus `copilot-instructions.md`, then reviews the full project and applies refactors only where guidelines demand it. File boundaries stay stable—no splitting modules into new paths—so diffs stay reviewable for solo founders juggling product and ops. When tests exist, passing them is a hard completion criterion, which anchors the skill in Ship-quality behavior rather than cosmetic churn. Use it after features land, before release branches, or when onboarding a new agent to an established repo whose rules live in .github docs.10.1kinstalls41Update Implementation PlanUpdate Implementation Plan is an agent skill for rewriting an existing implementation plan when requirements shift—new features, refactors, dependency upgrades, or infrastructure changes. Solo builders and small teams use it when the original plan is stale but still the source of truth for agent-driven execution. The skill treats the plan file as a deterministic contract: phases are discrete and atomic, tasks name concrete actions with parsing-friendly structure, and completion criteria are measurable so another agent or human can run phases independently. It fits the build and validate loop whenever you need to rebaseline scope without starting from a blank template, and it pairs naturally with skills that first authored the plan. Output emphasizes machine-readable sections over narrative prose so Copilot-class agents, Claude Code, or Cursor can chew through tasks in parallel where dependencies allow.10kinstalls42Make Repo ContributionMake Repo Contribution is an agent skill from the awesome-copilot collection that embeds opinionated GitHub issue and pull request templates into your workflow. Solo and indie builders use it when they want every contribution—bug reports, feature requests, or shipped fixes—to follow the same narrative structure reviewers expect. The issue side forces a one-sentence summary, explicit context, a proposed solution with affected areas, and measurable acceptance criteria with checkboxes. The PR side mirrors that discipline with a short summary, background tied to issues, grouped change lists, and a testing section that documents validation commands. It does not run CI or open PRs for you; it standardizes what you write so maintainers spend less time guessing intent. Best paired with repos you fork or upstream, hackathon contributions, or any project where sloppy tickets slow you down.10kinstalls43EditorconfigEditorconfig is an agent skill that acts as an EditorConfig Expert: it inspects your repository layout and languages, merges your stated preferences, and outputs a comprehensive `.editorconfig` with justified rules. Solo builders reach for it when a new monorepo mixes Python, JavaScript, Markdown, and config files and every IDE formats differently. The skill requires context analysis first, then layers universal hygiene (UTF-8, LF, trim trailing whitespace, insert final newline) plus targeted sections via globs. If you insist on tab width 2 while a common practice differs, the skill follows you and documents the tradeoff in prose. It does not replace Prettier or ESLint but removes the lowest-friction source of diff noise. Ideal early in Build when bootstrapping or after cloning a template that shipped without editor defaults.9.9kinstalls44Java Docsjava-docs is an agent skill that encodes Java Javadoc best practices so your coding agent documents types the way reviewers and IDEs expect. It targets solo and indie builders maintaining libraries, Spring services, or Android-adjacent JVM code who want public and protected APIs explained consistently without re-pasting style guides into every chat. Invoke it when adding new classes or methods, during API refactors, or before opening a PR that touches surfaced types. The skill walks through summary-first comments, parameter and return documentation, exception contracts, cross-references, inheritance via {@inheritDoc}, generics notation, and safe inline or block code samples. It also covers deprecation and version metadata so generated docs and JavaDoc HTML stay trustworthy. Pair it with your normal implementation flow; it does not run builds or generate sites—it steers comment quality at the source.9.8kinstalls45My Pull Requestsmy-pull-requests is a lightweight GitHub workflow skill for solo builders who lose track of open work across branches. It instructs the agent to resolve the current repository via #githubRepo, list pull requests assigned to you with #list_pull_requests, and return a readable brief for each item: what it does, what changed at a high level, and what needs attention next. When a PR is stalled on review, the skill asks the agent to highlight that explicitly so you can ping reviewers or self-assign follow-up. If CI or other checks failed, the response should name the failure class and propose fix directions instead of only quoting logs. When Copilot review has not run, the skill nudges the agent to offer requesting one through #request_copilot_review. It assumes your environment exposes those GitHub tools; it does not replace full code review skills or merge automation.9.8kinstalls46Apple Appstore ReviewerApple App Store Reviewer is an agent skill that role-plays an App Store reviewer so solo iOS builders catch rejection vectors before upload. On the first pass it must not edit code; it reviews source, Info.plist, entitlements, privacy manifests, StoreKit configuration, onboarding, paywalls, and related artifacts, then outputs a prioritized list reducing rejection probability while improving privacy, permissions, subscriptions, safety, and reviewer clarity. Assumptions are stated when files are missing. Use it when you are nearing submission, after a major IAP or privacy change, or when a binary was rejected and you need a structured guideline-oriented audit. It fits Launch ASO as the canonical home because outcomes are store approval and trust signals, with natural overlap into Ship security and launch distribution prep. Beginner-friendly for founders who do not memorize every guideline section.9.6kinstalls47Python Mcp Server GeneratorPython MCP Server Generator is an agent skill that turns a short natural-language brief into a complete Model Context Protocol server in Python. Solo and indie builders use it when they need custom tools inside Claude Code, Cursor, Codex, or Windsurf without hand-rolling boilerplate. The skill specifies uv-based project initialization, FastMCP configuration, at least one typed tool with clear docstrings, transport selection between stdio and streamable-http, and defensive error handling. It matters because MCP is the practical bridge between your product logic and agent clients; a consistent structure speeds review, packaging, and iteration. Invoke it during Build when you are adding agent integrations, not when you are still validating market fit or shipping production monitoring.9.6kinstalls48My IssuesMy Issues is a lightweight GitHub-oriented agent skill for solo builders who live in one repo at a time. It searches the current repository, lists issues assigned to you, and suggests which ones deserve attention based on how long they have been open, how much discussion they attracted, and whether they remain open or closed. The skill does not replace a full project management suite; it compresses context gathering before you ask your agent to implement fixes or write release notes. Use it when you reopen a stale branch, return from support tickets, or need a ranked backlog slice without leaving the coding session. It assumes your agent can resolve repository context and call issue listing capabilities tied to GitHub.9.6kinstalls49Nano Banana Pro OpenrouterNano Banana Pro OpenRouter is an agent skill that shells out to generate_image.py so Claude Code, Cursor, or Codex can create or edit images through OpenRouter’s google/gemini-3-pro-image-preview model. Solo builders use it when they need hero shots, UI mocks, social creatives, or quick composites while coding, instead of switching to a separate design tool. The skill documents prompt-only runs, single-image edits with --input-image, and multi-image studio-style compositing with repeated --input-image flags. Output resolution is explicit at 1K, 2K, or 4K. Behavior is constrained to the documented modes and env requirements, which keeps the integration predictable for indie shipping velocity. It fits the build integrations shelf because the deliverable is files on disk wired into your repo or landing page workflow, not a standalone SaaS feature.9.6kinstalls50Agentic EvalAgentic Eval is an agent skill documenting patterns for self-critique, evaluator–optimizer pipelines, and rubric or LLM-as-judge scoring so outputs improve iteratively instead of stopping at the first draft. Solo builders shipping agent features or heavy codegen workflows use it when accuracy, compliance, or style guides matter more than raw speed. The overview diagram makes the loop explicit: generate, evaluate, critique, refine, then ship. Patterns span basic reflection with capped iterations through test-driven refinement for code. It fits multi-phase work: you apply it while building agent tooling and again while shipping when you harden prompts, evals, and release gates. The skill is methodology-heavy rather than a single API integration, so pairing it with your own test harness or production logging is expected. Confidence is high for pattern coverage; implementation depth depends on your stack.9.5kinstalls51Prompt BuilderPrompt Builder is an agent skill for solo and indie builders who want GitHub Copilot prompts that behave reliably instead of one-off chat instructions. It runs as a guided discovery: you answer targeted questions about filename, purpose, category, persona expertise, domain stack, task boundaries, tool hooks, and how outputs should be shaped for AI consumption. The skill then assembles a complete `.prompt.md` following repository conventions, with emphasis on clear personas, explicit tasks, and front matter that Copilot can load consistently. Use it when you are standardizing team prompts, shipping reusable codegen or review flows in VS Code, or replacing ad-hoc Copilot instructions with versioned prompt files. It matters because well-structured prompts reduce drift, make tooling repeatable across projects, and turn Copilot from a generic assistant into a named specialist for your stack.9.5kinstalls52Ai Prompt Engineering Safety ReviewAI Prompt Engineering Safety Review is for solo builders who ship LLM features, agent skills, or Copilot prompts and need more than a gut check before users see outputs. The skill positions the agent as a safety specialist and walks a structured analysis framework: harmful content and illegal-use risk, violence and discrimination, misinformation, bias patterns, and security issues such as jailbreak-friendly wording or sensitive data exfiltration. It balances critique with improvement recommendations and teaching notes so you learn durable prompt-hardening habits, not just a redlined paragraph. Use it when polishing customer-facing system prompts, auditing internal agent instructions, or reviewing third-party prompt templates before production. In a one-person shop, one weak prompt can become your entire compliance story—this skill helps you catch that before distribution, app store review, or growth campaigns amplify mistakes.9.5kinstalls53Pdftk ServerPDFtk Server skill documents how to put the classic `pdftk` command-line PDF toolkit on your Windows 10/11 or Linux workstation—the kind of boring-but-critical step solo builders skip until a deploy or invoice pipeline fails. It walks through `winget` fetch and running the Windows installer, distro-specific package installs on Debian/Ubuntu and Fedora-family systems, and a quick sanity check by invoking `pdftk` for built-in usage help. Licensing context covers GPL v2 for free use and when a commercial redistribution license applies if you bundle the binary. Treat this as reference material for agents automating document prep, batch merges for legal or ops PDFs, or CI steps that need deterministic PDF operations without a GUI. It is not a creative prompt workflow; it is install-and-run infrastructure knowledge you attach when your skill chain needs shell-level PDF manipulation.9.4kinstalls54Breakdown Feature PrdBreakdown Feature PRD is an agent skill that acts as a product manager for solo and indie builders shipping SaaS: you point it at a high-level Epic feature and it drafts a complete Product Requirements Document with problem, solution, impact, personas, and user stories. It is for founders and builders who need disciplined scope before agents or devs write specs or code, especially when work spans multiple services. Use it when a feature is named in an Epic but acceptance criteria, metrics, and stories are still fuzzy; the skill asks clarifying questions until the PRD is implementation-ready. It matters because ad-hoc feature chat rarely produces a durable file the team can review, version, and hand to a technical-spec or planning skill. Output is Markdown PRD saved under a predictable docs tree, aligning solo builders with the same artifact larger platforms expect before build and ship phases.9.4kinstalls55Create Github Action Workflow SpecificationCreate GitHub Action Workflow Specification helps solo builders and small teams capture how an existing GitHub Actions pipeline really behaves in a formal Markdown spec optimized for AI assistants and future you. You nominate a workflow file; the skill produces a versioned document describing purpose, triggers, environments, and execution flow using dense structure rather than copy-pasted action syntax. Use it when workflows grew organically, onboarding is painful, or you want agents to propose changes without hallucinating job names. It fits the Ship phase because release safety depends on understanding CI/CD constraints before edits, refactors, or security hardening. The output is maintenance-friendly and explicitly abstracted from tool versions, which keeps specs valid longer than inline comments in YAML alone.9.4kinstalls56Dataverse Python Production CodeDataverse Python Production Code is an agent skill that turns natural-language requests into production-ready Python using the PowerPlatform-Dataverse-Client SDK. Solo builders and small teams use it when they need to read or write Dataverse records without hand-rolling fragile HTTP calls or missing platform-specific error semantics. The skill encodes Microsoft-aligned patterns: centralized logging, typed exceptions, resilient retries, and OData queries that minimize payload size. It fits agents in Claude Code, Cursor, or Codex that already have environment access and a Dataverse connection string or auth flow. Invoke it during backend integration sprints when you want maintainable modules instead of one-off snippets that break under rate limits or schema changes.9.3kinstalls57Markdown To HtmlMarkdown to HTML is an agent skill from GitHub’s awesome-copilot collection that gives precise Markdown-to-HTML equivalence examples for common documentation patterns—headings, paragraphs, inline emphasis, strikethrough, and blockquotes—so solo builders can generate or validate HTML when shipping docs, blogs, or in-app help. It is a phase-specific Build → Docs tool: you reach for it while implementing renderers, migrating README content to a site generator, or double-checking that agent-produced HTML matches expected GitHub-flavored Markdown behavior. The skill is essentially a structured cheat sheet with paired source and output snippets rather than a multi-step workflow. Complexity stays beginner-friendly because it documents deterministic syntax rules. It does not cover full CMS pipelines or security sanitization of untrusted Markdown; pair it with a dedicated HTML sanitizer skill when user-generated content is in scope.9.3kinstalls58Appinsights InstrumentationAppInsights instrumentation is an agent skill for solo builders who need real telemetry on Azure-hosted web apps without guessing SDK steps. It walks you through confirming stack and hosting, choosing auto-instrumentation when the app is ASP.NET Core on App Service, or provisioning an Application Insights resource and patching code for Node.js and other manual cases. The workflow emphasizes reading the repo to infer framework details, validating assumptions with you, and following reference docs for Bicep and AUTO setup. It fits when a product is shipping or already live and you want centralized logs, requests, and dependency traces in Azure rather than ad-hoc logging. It is not a generic logging refactor for local-only apps outside the stated Azure + web stack constraints.9.3kinstalls59Azure Deployment PreflightAzure Deployment Preflight is an agent skill that standardizes how you validate an Azure or Azure Developer CLI deployment before production push. It documents detection strings, exit-code behavior, and report templates for common authentication failures—az login, azd auth login, and expired tokens—while insisting on a continue-on-failure policy so solo builders see the full punch list instead of stopping at the first CLI error. The skill fits indie teams using azd templates or ARM/Bicep flows who want an agent to run preflight, skip blocked commands gracefully, and still complete other validation steps. Pair it with your existing infra skills when you are shipping SaaS or API workloads to Azure and need citable remediation steps aligned to Microsoft documentation.9.3kinstalls60Csharp Asynccsharp-async is an agent skill that encodes C# asynchronous programming best practices for solo and indie builders working in .NET backends, APIs, and shared libraries. When you paste code or ask for new async methods, the skill steers naming with the Async suffix, correct Task and ValueTask return types, disciplined exception propagation, and performance patterns such as WhenAll, WhenAny, and cancellation tokens. It also flags common foot-guns—blocking on .Wait or .Result, async void outside event handlers, and unnecessary async layers—that cause deadlocks and flaky production behavior. Use it during active backend implementation and again before ship when reviewing concurrency-sensitive paths. The skill is procedural guidance, not a linter replacement; pair it with your test suite and static analysis. Intermediate familiarity with C# helps; beginners still benefit from the pitfall checklist. It does not install packages or run builds—it shapes how your coding agent writes async code consistently across Claude Code, Cursor, and similar agents.9.2kinstalls61Mcp CliMCP-cli is a command-line interface skill for Model Context Protocol servers, aimed at solo builders who need fast discovery and execution without writing bespoke client code for every tool. It documents how to list configured servers and tool names, drill into parameters, pull full JSON input schemas, and invoke tools with JSON payloads, plus a grep helper to find tools by glob. The skill is ideal when you are integrating agent workflows in Build, validating MCP setups during Ship testing, or debugging tool calls in Operate. It assumes mcp-cli is available in the environment and that MCP servers are already configured. Compared to authoring servers, this skill is purely operational CLI knowledge for driving existing MCP infrastructure from the shell alongside Claude Code, Cursor, or Codex sessions.9.2kinstalls62Create Architectural Decision Recordcreate-architectural-decision-record is an agent skill that turns a settled technical choice into a repo-native Architectural Decision Record optimized for both human readers and AI parsers. You supply decision title, context, the chosen option, rejected alternatives, and stakeholders; the skill refuses to fabricate ADRs when required inputs are missing, then emits markdown following a fixed template with positive and negative consequences and rejection rationale. Files land in /docs/adr/ with zero-padded sequence numbers so your decision log stays ordered. Solo builders use it when picking databases, auth providers, deployment targets, or agent orchestration patterns—moments where chat memory is insufficient. It spans Validate when narrowing scope and Build when documenting what you implemented, but the canonical shelf is Build/docs. The skill is a generator, not a facilitation workshop; brainstorm alternatives elsewhere first. Deliverables are single ADR files ready for PR review. Pair with planning skills when the decision follows an approved spec. Does not execute migrations or provision cloud resources—it only documents the why.9.2kinstalls63Refactor Method Complexity ReduceRefactor Method Complexity Reduce is a structured agent workflow for developers whose linter or review flagged one method as too cognitively complex. You supply the method name and a complexity ceiling; the skill directs analysis of nested conditionals, duplicated case logic, loop-plus-condition patterns, and sprawling boolean expressions, then plans extractions into validation helpers, type-specific handlers, and small utilities with appropriate visibility and async shape. The main method becomes an orchestrator with shallower nesting and clearer control flow—aligned with common Sonar or IDE cognitive-complexity rules. It fits solo builders cleaning up legacy modules before ship, or tightening a hot path after a bug fix. It assumes the method exists in the open workspace and that complexity is measured in a way your toolchain understands; it does not replace whole-architecture refactors or broad dead-code elimination across the repo.9.2kinstalls64Azure Role SelectorAzure Role Selector is an agent skill for solo builders and small teams who need to grant Azure access without over-provisioning. When you know what an identity must be able to do—but not which built-in role fits—the skill walks through matching requirements to RBAC roles with least privilege, then outlines how to assign that role. It is built around Microsoft’s Azure MCP surfaces for documentation, Bicep schema awareness, extension CLI generation, and platform best practices, so recommendations stay tied to official role definitions rather than guesswork. Use it during app registration, CI/CD service principals, managed identities for workloads, or any IAM change where a too-broad Contributor grant would violate your security posture. It does not replace your org’s custom role definitions or policy exceptions; it accelerates the standard built-in role decision and assignment narrative for typical solo-ship scenarios.9.2kinstalls65Plantuml AsciiPlantUML ASCII is a generator skill for solo builders who want diagrams that diff cleanly in Git and render in terminals without image hosting. When someone asks for ASCII art diagrams, text-based sequence or class views, or PlantUML text mode, the skill guides installation on macOS and Linux, explains -txt versus -utxt output, and helps author PlantUML sources that compile to readable ASCII for README files, PR descriptions, runbooks, or email. It complements graphical PlantUML workflows rather than replacing them—ideal when CI or review policies discourage binary images or when you need quick architecture sketches in agent-driven doc updates. You need PlantUML available locally or via JAR, and shell access to run the CLI; the skill focuses on creation and conversion, not on live rendering servers or C4 macro-heavy styling unless you supply the source.9.2kinstalls66Meeting MinutesMeeting Minutes is an agent skill from the awesome-copilot collection for solo founders and small teams who need fast, consistent records from standups, design reviews, triage, and short planning sessions. It walks a deliberate intake phase—title, date, duration, organizer, audience, and available transcript or notes—then structures capture around attendees, agenda items, and time markers when present. The designed output emphasizes decisions and action items with owners and due dates so you can paste outcomes into GitHub Issues or Jira without rewriting. Use it whenever internal syncs need a repeatable minutes format rather than freeform chat summaries. Complexity stays beginner-friendly because the skill defines operational phases and discovery limits instead of requiring a custom template each meeting.9.2kinstalls67Image Manipulation Image MagickImage Manipulation with ImageMagick is an agent skill that wraps common ImageMagick CLI workflows for solo builders who need reliable image ops inside Claude Code, Cursor, or Codex. It targets moments when you are generating thumbnails, converting formats, batch-resizing screenshots or marketing art, or pulling width-by-height metadata before shipping UI or content. The skill documents prerequisites clearly: ImageMagick must be installed and callable as `magick`, with platform-specific notes for Windows PowerShell versus Linux or macOS Bash. Capabilities are grouped into information retrieval, resizing (single and batch), and format conversion patterns suited to repeatable agent execution rather than one-off chat guesses. Use it when your repo or deploy pipeline references binary assets and you want the agent to emit correct commands instead of pseudo-syntax. It is a focused integration skill—not a creative design tool—so pairing it with your own brand guidelines still matters.9.1kinstalls68Scoutqa TestScoutQA Test is an agent skill that wires ScoutQA’s CLI into your coding workflow so you can delegate exploratory QA instead of only manual click-throughs. Solo and indie builders shipping SaaS, marketing sites, or e-commerce frontends use it when someone asks to test a site, verify login, or hunt accessibility issues—and equally after the agent implements a form, checkout, or auth change. The skill frames ScoutQA as an intelligent testing partner you can run in parallel for smoke, user-journey, and audit-style passes. It fits the Ship phase first, but proactive verification right after Build work is a documented pattern, so it spans build-then-ship habits without replacing unit or integration tests in the repo.9.1kinstalls69Write Coding Standards From FileWrite Coding Standards From File helps solo builders and tiny teams codify how their project already looks in code—not how a generic linter pamphlet says it should look. The agent reads one required file (`${fileName}`) or optionally aggregates a folder, accumulates syntax patterns into a single analytical view, and drafts a standards or style guide aligned with those observations. Configuration toggles shape behavior: create a new markdown file versus enrich README, choose insertion placement, fetch external style URLs when enabled, and optionally find or fix inconsistencies before publishing guidance. Default tendencies in the skill bias toward creating dedicated docs (often CODING_STANDARDS.md-class filenames) and inserting summaries near the end of README when that path is chosen. This is ideal when you are mid-build and need contributor-ready norms before PR volume grows. It complements automated formatters by capturing naming, structure, and idioms formatters miss. Pair it with your formatter config so human-readable rules and machine enforcement stay aligned.9.1kinstalls70Csharp XunitC# XUnit is an agent skill that encodes Microsoft-ecosystem unit testing conventions so solo builders do not reinvent project layout, attributes, or naming every time they add a .NET service or library. It walks through test project naming, package references, AAA structure, independent idempotent tests, and the split between simple Facts and parameterized Theories. Fixtures cover constructor teardown and class/collection-scoped shared context. The audience is indie developers shipping APIs, internal tools, or small SaaS backends who want tests that read clearly in PRs and run reliably via dotnet test in Ship workflows, without the ceremony of heavier test frameworks.9.1kinstalls71Kotlin SpringbootKotlin-springboot helps solo builders and small teams write maintainable server-side code with Spring Boot using Kotlin idioms instead of translated Java style. The skill spans project setup with Maven or Gradle, starter dependencies, and structural conventions such as organizing packages by feature or domain. It reinforces dependency injection through primary constructors, immutability with val, and standard stereotypes for services, repositories, and REST controllers. Configuration guidance favors readable application.yml and type-safe properties classes. JPA-focused notes include enabling the kotlin-jpa plugin so entity classes remain open without repetitive openness modifiers. Reach for this skill while you are actively implementing APIs, persistence, and service layers—not when you are only validating market fit or tuning production monitors. It is a backend build companion for JVM APIs and SaaS backends rather than a testing or DevOps automation pack.9.1kinstalls72Powerbi ModelingPower BI Modeling is an agent skill that standardizes how solo builders and small teams label tables, columns, and DAX measures so dashboards stay readable months later. It documents dimension versus fact naming, bridge tables, underscore-prefixed measure tables, and explicit measures for metrics that need filter context or reuse across reports. The content targets indie operators who own their own BI semantic layer—subscription SaaS metrics, operations dashboards, or internal reporting—without a dedicated analytics engineer. It sits primarily in Grow when analytics mature, but the same rules apply while building data models in Validate prototypes or Operate when refining production datasets.9.1kinstalls73Copilot SdkCopilot-sdk is a procedural guide for solo and indie builders who want agentic behavior inside their own applications using GitHub’s Copilot SDK. It assumes you already run the GitHub Copilot CLI and a supported language runtime, then walks through package installation and quick-start patterns for Node/TypeScript, Python, Go, and .NET. The skill emphasizes that you define agent behavior while Copilot handles planning, tool invocation, and file-oriented actions—reducing the need for a bespoke orchestration layer. Use it when you are wiring embedded agents, custom tools, streaming UX, session lifecycle, or MCP connectivity in a product you are actively building. It sits in the build phase as agent-tooling documentation rather than a marketplace skill pack or a one-off codegen snippet, and pairs naturally with backend or frontend work once the hosting app exists.9.1kinstalls74Context MapContext Map is an agent skill from awesome-copilot that forces a structured reconnaissance pass before code changes. Given a task description, the agent searches for related files, traces direct dependencies, locates tests, and notes exemplar patterns, then outputs markdown tables for modifications, dependency ripple, test coverage, references, and risk flags. Solo builders use it to avoid blind edits in unfamiliar repos and to give reviewers a single artifact that explains blast radius. It fits multi-phase work: most often in Build when scoping a feature or fix, and again in Ship when a change needs the same discipline before review or release. The skill’s hard stop—no implementation until the map is reviewed—makes it a lightweight change-management ritual for agentic coding sessions.9.1kinstalls75Agent GovernanceAgent Governance Patterns is an agent skill from awesome-copilot that teaches reusable safety and control layers for systems where LLMs invoke external tools. Solo and indie builders shipping agent products use it when a prototype can already call APIs, databases, shells, or delegate to other agents but lacks explicit boundaries. The skill walks through semantic intent classification to catch dangerous prompts, policy-based access control for which tools run under which conditions, trust scoring across multi-agent handoffs, and durable audit trails for decisions and actions. It also covers operational guardrails such as rate limits and content filters. You apply the patterns during implementation in Build, then rely on the same controls through Ship security review and Operate monitoring. It is reference-style procedural knowledge—not a hosted governance product—so you adapt the pipeline to your stack while keeping the same accountability model.9.1kinstalls76Devops Rollout PlanDevOps Rollout Plan is an agent skill that turns a change description and environment context into a comprehensive, production-oriented rollout plan. Solo and indie builders shipping SaaS, APIs, or containerized apps use it when they need more than an ad-hoc deploy checklist: explicit preflight gates, ordered deployment steps, verification signals, rollback paths, and stakeholder communication. The skill asks for what is changing, from/to versions, affected services, capacity, downtime windows, approvals, and compliance before generating output. That structure reduces the chance of shipping blind on schema migrations or multi-service releases. It fits operators who own their own releases without a dedicated release-management team and want a repeatable artifact they can review with a technical lead or paste into a runbook.9.1kinstalls77Boost PromptBoost Prompt is a journey-wide agent skill for interactive prompt refinement aimed at solo builders who want agent sessions to start from a crisp brief instead of vague chat. The workflow interrogates task scope and objectives, asks targeted questions through Joyride’s human-input tool, explores the project when helpful, and organizes the result into clear sections and steps with explicit success criteria. When the draft is ready, it writes markdown to the clipboard using Joyride Clojure helpers and repeats that step after revisions. It never generates application code, which keeps the skill focused on planning and communication quality. You reach for it in Validate when scoping a feature, in Build before a large refactor, in Ship before a review pass, or in Grow when drafting content workflows—anytime a better prompt saves rework. Requires the Joyride extension in a VS Code–compatible environment.9kinstalls78Git Flow Branch CreatorGit Flow Branch Creator is an agent skill that automates the boring git hygiene step of picking the right branch under the nvie Git Flow model. After you have local changes, the agent runs git status and git diff (or git diff --cached), applies an XML-documented analysis framework to classify the work—typically feature work branching from develop—and generates a semantic branch name before creating and checking out the branch. Solo builders use it to stay consistent with Git Flow naming without memorizing rules every sprint. It fits the Build phase when you start a feature, enhancement, or fix that should merge back to develop through your usual PR flow. The skill is procedural and shell-oriented rather than a GUI plugin; you still own merges, releases, and hotfix policy on main/master. Pair it with your existing CI and review skills once the branch exists.9kinstalls79Create Github Pull Request From SpecificationCreate-github-pull-request-from-specification is for solo builders who finish a feature branch against a written spec and want GitHub hygiene without manual copy-paste. The skill reads the workspace pull request template, creates or reuses a draft PR on the target branch, pulls the diff when needed, and updates title and body so reviewers see specification-aligned context. It then flips the PR out of draft, assigns the creating user, and returns the PR URL. Use it when one specification should map to exactly one pull request and your agent has GitHub MCP or copilot tools (search, create_pull_request, get_pull_request_diff, update_pull_request, get_me, update_issue). It reduces review friction for indie repos where the PR template is the source of truth for acceptance criteria.9kinstalls80Readme Blueprint Generatorreadme-blueprint-generator is an agent skill for solo and indie builders who already maintain Copilot-oriented documentation under `.github/copilot` and want a polished README without manual copy-paste. It instructs the agent to inventory those files plus `copilot-instructions.md`, then synthesize a comprehensive README with project purpose, technology stack, architecture summary, standards, testing, and workflow notes drawn from the canonical doc set. It fits early in a repo’s life when you have internal docs but no public-facing README, and again when architecture or stack changes and the README has drifted. For AEO and SEO, it turns scattered agent context into one citable landing narrative for your repository. It is a procedural generator, not a live GitHub API integration—the agent reads files you already committed. Pair it after you finish a planning or architecture pass, or when onboarding contributors who expect a single entry point at the repo root.9kinstalls81Project Workflow Analysis Blueprint GeneratorProject-workflow-analysis-blueprint-generator is an awesome-copilot skill for solo builders and small teams who inherit or grow multi-layer codebases and need trustworthy workflow documentation without manually drawing every path. You point it at a repository, tune variables such as entry point type, persistence, architecture pattern, and how many flows to document, and the agent analyzes the tree to emit structured blueprints from API or UI entry through services, storage, errors, and tests. It is most often shelved under Build and docs because the primary artifact is documentation, but it also supports Ship planning when you want test patterns and error-handling maps before refactors. Detail level can stay standard or expand to implementation-ready notes, which helps agents and humans align on CQRS, layered, or event-driven shapes. It is a generator, not a runtime integration—expect narrative and diagram prompts, not deployed infrastructure.9kinstalls82Make Skill TemplateMake Skill Template is a meta capability for solo and indie builders who want to add reusable Agent Skills to GitHub Copilot without guessing folder layout or frontmatter rules. When someone asks to create, scaffold, or duplicate a skill, it walks through naming the directory, writing SKILL.md with name and description fields that double as discovery triggers, and optionally bundling scripts, references, assets, or templates. It assumes you already know what the skill should accomplish and which resources belong beside the markdown. The output is a spec-compliant skill package ready for Copilot to load, which matters because ad-hoc markdown files often miss triggers agents need to invoke the right procedure. Use it during Build when formalizing agent workflows, during Validate when prototyping a narrow automation, or anytime you are extending Copilot with procedural knowledge rather than one-off chat instructions.8.9kinstalls83Create Spring Boot Java ProjectCreate Spring Boot Java Project is a procedural generator for solo builders who want a production-shaped JVM API skeleton without manually clicking through Spring Initializr for every new service. It verifies Java 21, Docker, and Docker Compose, then downloads a zipped Maven project from start.spring.io with a sensible default dependency set: web layer, JPA, PostgreSQL, Redis, MongoDB, validation, cache, lombok, configuration processor, and Testcontainers for integration tests. You can override project name via artifactId, package name, and Boot version in the download step. The skill is phase-specific to Build backend work—ideal when you have validated the idea and need a consistent starting repo for APIs or SaaS backends. It assumes shell access and network to spring.io; it does not deploy or configure cloud infra beyond local Docker readiness.8.9kinstalls84Csharp Docscsharp-docs is an agent skill that keeps C# libraries and services documented with XML comments that match Microsoft-style online doc expectations. Solo builders shipping APIs or internal tools often skip comments until onboarding hurts; this skill enforces repeatable tags—summary tone, remarks for nuance, examples with language-attributed code blocks, and correct cref links—so DocFX, Sandcastle, or IDE quick info stay trustworthy. Invoke it while implementing new public surface area, during review when XML is missing or vague, or before a release when you refresh generated reference docs. It does not replace architecture guides; it makes each type and member self-explanatory enough that future-you and contributors can ship fixes without spelunking implementation details.8.9kinstalls85Breakdown PlanBreakdown Plan is an agent skill that acts as a senior project manager for solo and indie builders who already have product artifacts and need a executable GitHub plan. It ingests the full feature set—PRD, UX design, technical breakdown, and testing plan—and emits a comprehensive backlog organized as Epic, Feature, Story, Enabler, Test, and Task items with dependencies, priorities, and tracking suited to GitHub Projects. The workflow emphasizes Agile hierarchy, INVEST-quality stories, and explicit ready/done gates so agents and humans do not start unclear work. It fits builders shipping SaaS, APIs, or CLIs who want Kanban-style visibility without manually duplicating specs into issues. Use it after validation artifacts are drafted and before implementation sprints, when you need blocking relationships and enabler work called out beside user stories. The skill is prompt-driven planning automation, not a live GitHub API integration—you still apply the generated structure in your repo’s project tooling.8.9kinstalls86Dataverse Python Advanced Patternsdataverse-python-advanced-patterns is an agent skill for indie builders who embed Microsoft Dataverse in Python services—custom line-of-business apps, automation, or SaaS connectors—without learning every SDK edge case from scattered docs. It steers the agent toward production patterns: classify transient failures, configure http retries and timeouts, run batch mutations safely, craft efficient OData queries, manage table metadata and picklist cache invalidation, and choose chunked uploads for large files. When analytics-style access fits better than row-by-row APIs, it points to PandasODataClient. Expect typed, docstring-rich snippets tied to official API references rather than toy scripts. Use during backend implementation or hardening before you ship integrations that must survive rate limits, partial batch failures, and metadata drift in real tenants.8.9kinstalls87Dotnet UpgradeDotnet Upgrade packages ready-to-use prompts for solo builders and small teams maintaining .NET solutions that still target .NET Framework or older .NET Core lines. The skill walks through discovery—classifying every project, reading TargetFramework and SDK style, and mapping dependencies—then recommends upgrade order, incremental checkpoints, and whether to lean on Upgrade Assistant or manual edits. It explicitly calls out packages.config migrations, framework selection for libraries versus hosts, and progress tracking across build, test, and deploy readiness. The audience is an indie maintainer facing a multi-project solution or Azure Functions who cannot afford a silent production break during retargeting. Use it when you need a disciplined sequence before touching csproj files, not as a one-shot “bump the version” chat. Outputs are analysis and checklists your coding agent can follow step by step; you still run builds and tests locally or in CI.8.9kinstalls88RememberRemember is a journey-wide meta skill for builders who use VS Code–style agent setups and want lessons from debugging, workflow tweaks, and repeated errors to survive the next chat. Invoked with `/remember [>domain [scope]] lesson clue`, it routes each learning into domain-organized Memory Instructions either globally (`vscode-userdata:/User/prompts/`) or per workspace (`<workspace-root>/.github/instructions/`). The keeper discovers existing `*-memory.instructions.md` files, matches new clues to domains, or spins up new domain files so knowledge stays structured instead of buried in thread history. Solo developers wearing every hat benefit when the same agent forgets a repo-specific test command or a global preference for how to format commits. Use it whenever you finish a painful fix and want the pattern encoded for Cursor, Copilot-style, or Claude Code workflows that read instruction files. It does not run your code—it maintains the instruction layer your other skills and tasks depend on.8.9kinstalls89Ef Coreef-core is an agent skill that steers solo and indie builders through Entity Framework Core best practices when they model data, write queries, or ship schema changes in ASP.NET or .NET APIs. It covers how to keep DbContexts cohesive, configure entities with fluent API or separate configuration classes, and design relationships without leaking performance problems into production. The guidance emphasizes read-path efficiency—no-tracking queries, selective projection, eager loading only when justified—and migration hygiene so production rollouts stay reversible and reviewable. Invoke it while scaffolding a new service, refactoring a bloated DbContext, or before merging migrations that will run against real databases. It does not replace provider-specific tuning or raw SQL for extreme cases; it gives a consistent checklist so your agent does not default to tracked queries, lazy N+1 loads, or monolithic migration dumps.8.9kinstalls90Next Intl Add Languagenext-intl-add-language is a phase-specific agent skill for solo builders extending a Next.js application that already uses next-intl. It walks through the concrete file touchpoints: duplicate and translate every entry from the English message catalog, register the locale in routing and middleware so URLs and detection stay consistent, and expose the language in the existing toggle component. The intent is completeness—partial translations break UX—so the skill stresses parity across JSON keys before shipping the new locale. Use it when you are launching in a new market, supporting a bilingual landing product, or onboarding community translators without guessing which config files next-intl expects. It is not a generic i18n strategy skill; it is an implementation runbook tied to this repo layout and next-intl conventions.8.8kinstalls91Breakdown Feature Implementationbreakdown-feature-implementation is an agent skill that helps solo builders and small teams translate a Feature PRD into a thorough technical implementation plan before anyone opens an IDE for feature code. It adopts a senior-engineer planning voice, emphasizes Epoch’s monorepo conventions under apps, services, and packages, and requires a Mermaid diagram that ties frontend UI, APIs, and integration points into one system view. The deliverable is a structured Markdown document with goals, bulleted requirements, and technical considerations—not a pile of commits—so agents and humans share the same execution map. Use it after product scope exists but before sprint breakdown or ticket slicing. Pair it with your org’s PRD source and review gates; it will not replace validation with users or automated test design, but it reduces ad-hoc “just start coding” drift on multi-repo SaaS features.8.8kinstalls92Add Educational CommentsAdd Educational Comments is an agent skill that turns a single code file into a structured learning resource by inserting educator-style inline comments. It positions the agent as a technical writer who explains foundations for beginners, practical patterns for intermediates, and architecture or performance context for advanced readers, always following fixed Educational Commenting Rules. Solo builders use it when onboarding contributors, documenting legacy modules, or studying unfamiliar code in Claude Code, Cursor, or Codex without maintaining a separate course. The skill requests a file path when missing and can suggest numbered near-matches for quick selection. Default behavior grows the file to 125% of its original line count using comments only, capped at 400 new lines; files already processed get refreshed commentary rather than another bulk expansion. Outputs stay buildable and structurally identical aside from annotations.8.8kinstalls93Power Bi Report Design ConsultationPower BI Report Design Consultation is an agent skill that acts as a visualization and UX specialist for Microsoft Power BI. It walks solo builders and analysts through a design consultation framework before they commit to visuals: business context (problem, audience, decisions, KPIs, delivery channel), data context (types, granularity, hierarchies, comparisons), and technical constraints (performance, accessibility, branding, mobile). A chart selection methodology helps match encodings to the insight rather than defaulting to crowded dashboards. The skill is suited when you are scoping an executive summary, an operational monitor, or a self-serve analytics page and want defensible layout and chart choices early. It spans Validate when defining metrics, Build when implementing report pages, and Grow when refining analytics products customers rely on. It does not replace DAX modeling or dataset engineering—it front-loads design quality for reports that must be readable under real decision pressure.8.8kinstalls94Update SpecificationUpdate Specification is an agent skill for solo builders who treat markdown specs as the contract between humans and coding agents. When requirements shift or the codebase diverges from what you documented, the skill guides a full refresh of the target file so requirements, constraints, and component interfaces stay unambiguous and structured for LLM consumption. It bakes in documentation discipline—distinguishing must-haves from recommendations, avoiding fuzzy language, and formatting for easy parsing—while routing finished work into the `/spec/` directory with a predictable naming scheme tied to document intent. That pairing helps indie teams avoid silent drift: agents stop hallucinating APIs that were removed, and you keep validate-and-build phases aligned without rewriting specs from scratch in chat every sprint.8.8kinstalls95Java Refactoring Extract MethodJava Refactoring Extract Method is a narrow agent skill for solo builders maintaining Java backends who want one reliable refactor move—not a whole style guide. It casts the agent in an expert role and anchors behavior with two full before-and-after examples: conditional setter guards on a builder, and branching logic in a relationship expander. The pattern is consistent—identify a coherent block, name it, replace inline noise with a call—so agents stop rewriting entire classes when you only need a readable helper. For indie SaaS and API services on the JVM, this fits the ship-and-review lane when methods grew under time pressure. It does not replace tests or broader refactors like inline class or move method; it makes Extract Method repeatable in Claude Code, Cursor, or Codex sessions.8.8kinstalls96Breakdown Testbreakdown-test is an agent skill packaged as a senior QA engineer prompt for solo and indie builders who manage work on GitHub. You feed it feature artifacts—a feature PRD, a technical breakdown, and an implementation plan—and it generates comprehensive test planning, task decomposition, and quality assurance documentation aligned with ISTQB process thinking and the ISO 25010 quality model. The workflow emphasizes risk-based prioritization, multiple test types (functional, non-functional, structural, change-related), and explicit quality gates so you know when testing can start and when a slice is safe to release. It fits naturally after planning or implementation breakdown skills and before execution-heavy testing or release checklists. Use it when you want agent-assisted strategy instead of ad-hoc test bullets in issues, especially when you need traceability from requirements to test cases for a small team wearing every hat.8.8kinstalls97Snowflake SemanticviewSnowflake Semantic View is an agent skill for solo builders and tiny data teams who need a repeatable path from star-schema tables to a Snowflake semantic layer without guessing DDL. It starts with practical CLI onboarding—confirm `snow` works, link connections, then for each request nail down database, schema, role, warehouse, and the final view name while insisting on a classic star schema. The agent drafts CREATE or ALTER SEMANTIC VIEW statements using Snowflake’s documented syntax, enriches dimensions, facts, and metrics with synonyms and comments (often seeded from existing Snowflake metadata), and validates through the CLI so errors surface before production. That fits build-time analytics integrations for SaaS products where you want AI tools and BI consumers to hit consistent metric definitions instead of raw SQL chaos.8.8kinstalls98Rust Mcp Server Generatorrust-mcp-server-generator is an agent skill that acts as a Rust MCP server scaffolder for solo builders who want agent-callable tools without hand-rolling boilerplate. After a short discovery pass—project name, server description, transport type, which tools to expose, and whether prompts and resources are needed—it materializes a conventional layout with Cargo.toml, src modules for handlers and per-tool files, and an integration test stub using the official rmcp SDK. Transport flexibility covers stdio for local agents, SSE or HTTP for remote bridges, or all transports when you are unsure yet. The generated project wires serde JSON schemas, anyhow error handling, and tracing subscribers so you can iterate toward production behavior. It is ideal when you are extending your coding agent with domain-specific capabilities in Rust rather than wrapping yet another REST script in Python.8.8kinstalls99Vscode Ext Commandsvscode-ext-commands is an agent skill that encodes Microsoft’s contribution patterns for commands in VS Code extensions, aimed at indie developers who ship editor extensions alongside their products. It clarifies when a command is a regular palette action versus a Side Bar–only control, including the `_extensionId.command#sideBar` naming convention, mandatory titles, category usage, and when icons are required. The guidance covers placement in view titles and item context menus, relative ordering via groups, and enablement expressions so buttons do not appear when state is invalid. Use it whenever you add or update commands in package.json so palette clutter, broken Side Bar buttons, and missing localization hooks do not slip through review. It complements broader extension scaffolding skills by focusing narrowly on command hygiene and discoverability inside VS Code’s UI surfaces.8.8kinstalls100Folder Structure Blueprint GeneratorFolder Structure Blueprint Generator is an agent skill that analyzes an existing project and produces a technology-agnostic folder-structure blueprint. It is aimed at solo and indie builders who want consistent code organization without adopting a single framework’s dogma. You invoke it when starting a new module, refactoring a messy tree, or writing onboarding docs for a multi-stack repo. The skill auto-detects common stacks and architecture hints (monorepo, microservices, frontend), then emits visualization-ready structure maps, naming conventions, file-placement patterns, and optional starter templates for new work. That makes later agent sessions and human contributors follow the same rules instead of inventing paths ad hoc. It matters on Prism because clear structure reduces agent hallucination about where files live and speeds reviews during Validate scoping and Build delivery.8.7kinstalls101Finnish HumanizerFinnish Humanizer is an agent skill for builders and marketers who publish in Finnish but draft with AI assistance. It acts as a Finnish-language editorial pass: it hunts AI-generated tells and style tells, then rewrites so the result sounds like a deliberate human author—not a polished machine translation. The documented scope covers twenty-six patterns split between Finland-specific habits and universal LLM quirks, plus four style markers, all interpreted through a cultural voice brief (suoruus, lyhyys, skeptical hype, purposeful silence). Use it while tightening blog posts, product copy, help articles, or investor updates stored as markdown or plain text. It does not replace spellcheck or localization QA; it assumes the facts are right and the tone is wrong. For solo founders serving Finnish customers, running this skill before publish reduces the “ChatGPT Finnish” smell that undermines trust in growth and launch channels alike.8.7kinstalls102Create LlmsCreate LLMs is an agent skill for solo and indie builders who want their GitHub (or local) repos to be legible to Claude Code, Cursor, Codex, and other agents—not only to humans skimming a README. It walks through compliance with the llms.txt specification, inspects how the project is organized, and surfaces the files and folders that actually explain what the product does and how to work in the codebase. You invoke it when you are shipping or polishing a public repo, preparing an SDK for agent consumers, or tightening documentation after a big refactor. The output is a structured llms.txt that acts as a map: what this repo is for, where to read next, and which paths matter for implementation. That reduces wasted agent tokens, mis-parsed monorepos, and hand-wavy “read the whole repo” prompts. It fits early validate scoping when you define what is public-facing, build/docs when you maintain developer surfaces, and launch/geo when you care that AI search and coding tools route newcomers correctly.8.7kinstalls103Microsoft Skill Creatormicrosoft-skill-creator is a meta authoring skill for solo and indie builders who package Microsoft SDK, client library, and framework know-how into agent-ready SKILL.md files. It supplies a structured SDK/Library template—name and description frontmatter, installation, key concepts, quick start, and common patterns—so agents do not improvise inconsistent skill shapes. Because many setups lack the Learn MCP server, the skill documents a practical fallback: replace microsoft_docs_search, microsoft_code_sample_search, and microsoft_docs_fetch with equivalent mslearn search, code-search, and fetch commands via npx @microsoft/learn-cli or a global install. Use it when you are adding or extending skills for Azure, .NET, or other Learn-documented stacks in Claude Code, Cursor, or Codex workflows. It reduces duplicated boilerplate and keeps documentation retrieval explicit in the skill body, which improves repeatability and AEO-friendly detail pages in catalogs like Prism.8.7kinstalls104Openapi To Application CodeOpenAPI to Application Code is an agent skill for solo and indie builders who already have—or can fetch—an OpenAPI document and want a full application scaffold instead of typing every endpoint by hand. You supply the spec plus optional project name, framework version, naming conventions, and authentication details when the contract is incomplete. The workflow walks through spec analysis, architecture design, and code generation using your active framework’s conventions. It is strongest when the OpenAPI definition is reasonably complete and you are ready to iterate in a real repo. Use it during Validate when you need a fast API-backed prototype, or during Build when you are implementing or integrating against a published contract. It does not replace product discovery, security review, or deployment—you still own testing, hardening, and shipping after the scaffold lands.8.7kinstalls105Aspnet Minimal Api Openapiaspnet-minimal-api-openapi is an agent skill that walks solo and indie builders through ASP.NET Minimal API endpoint design with production-grade typing and Swagger-ready documentation. It targets the Build phase when you are turning a product spec into HTTP surfaces: grouped routes, immutable record DTOs, validation attributes, and strongly typed return shapes using Results and TypedResults. The skill emphasizes error consistency through ProblemDetails and status-code pages, plus OpenAPI operation identity so client generators and API consumers stay aligned. It fits .NET 9 stacks where built-in OpenAPI document generation replaces ad-hoc annotation sprawl. Use it when your agent keeps producing anonymous endpoints, weak response typing, or undocumented operations that break contract reviews and frontend integration.8.7kinstalls106Breakdown Epic Pmbreakdown-epic-pm is an agent skill that prompts your coding agent to behave as an expert product manager and produce Epic-level Product Requirements Documents for sizable SaaS initiatives. Solo founders and small teams use it when a feature theme is agreed in principle but engineering needs a durable narrative—problem, solution, impact, personas, and journeys—before anyone writes architecture or tickets. The skill instructs the agent to ask clarifying questions when the request is underspecified, then emit a complete PRD in Markdown at a fixed docs path convention under ways-of-work planning folders. That document is meant to be the handoff artifact for a follow-on technical architecture specification, keeping product intent separate from implementation design. It fits early Validate work and remains useful in Build PM rituals when splitting roadmaps into epics.8.7kinstalls107Create Github Issues Feature From Implementation Plancreate-github-issues-feature-from-implementation-plan bridges written implementation plans and a GitHub backlog solo builders can ship against. The agent reads `${file}`, splits work by plan phases, searches for existing issues to avoid duplicates, then creates or updates issues using feature_request.yml or chore_request.yml when present. Each issue carries the phase name as title plus requirements copied from the plan—no scope creep beyond what the document demands. It is most valuable right after planning or spec approval when you would otherwise paste tasks into chat or a personal todo list. Compatible with Claude Code, Cursor, and Codex setups that expose GitHub issue tools. Pair it after plan-writing skills so every phase becomes a visible, labelable unit of work before frontend or backend implementation begins.8.7kinstalls108Remember Interactive ProgrammingRemember Interactive Programming is a compact agent skill—originally aimed at Clojure and Copilot with a REPL—that reframes the assistant as an interactive programmer. Instead of guessing from static files alone, the agent is instructed to explore and modify the running system through evaluation, treat the REPL as authoritative, and narrate what it runs because the human never sees raw eval results. It nudges structural edits for file changes and ongoing todo hygiene. Solo and indie builders who ship with agent-assisted REPL workflows (Backseat Driver, Clojure, or any language with a live eval channel) install it to stop one-shot hallucination-heavy edits and align day-to-day coding with discover-test-change loops. It is workflow glue, not a server or generator: paste or wire it into your skill set and tune reminders for your workspace.8.7kinstalls109Debian Linux TriageDebian Linux Triage is an agent skill that walks you through diagnosing and fixing Debian host problems using the tools Debian admins actually use: systemd for services, journalctl for logs, apt and dpkg for packages, with awareness of AppArmor and firewall context when relevant. It is aimed at solo builders and small teams who self-host APIs, run CI runners, or maintain VPS instances without a dedicated SRE on call. You supply an optional release, a problem summary, and constraints; the skill confirms assumptions, proposes a step-by-step plan, outputs remediation in code blocks, and pairs every major change with verification commands plus rollback guidance. Use it when SSH works but services crash, upgrades break dependencies, or a container host misbehaves on Debian. It is procedural operational knowledge packaged for Claude Code, Cursor, Codex, and similar agents—not a remote monitoring product.8.7kinstalls110AspireThis Aspire skill is a deep-dive reference on Microsoft .NET Aspire’s internal architecture: the Developer Control Plane that powers aspire run, the hierarchical resource model, networking and service discovery, telemetry, and how local development relates to Kubernetes production paths. Solo builders shipping multi-project .NET APIs, workers, and dependencies get a mental model for why containers and executables are managed through a K8s-like API on one machine, and what changes when you promote to a real cluster. Use it while designing Aspire AppHost projects, debugging why resources fail to start locally, or explaining DCP versus full Kubernetes to stakeholders. It complements hands-on coding skills rather than replacing official Aspire templates. The excerpt centers architecture knowledge for agents helping you in Build, then Ship and Operate when deployment topology matters.8.7kinstalls111Azure Static Web Appsazure-static-web-apps helps solo builders host static frontends on Azure with optional serverless APIs and realistic local emulation. It standardizes on the SWA CLI (`swa`) for init, start, login, and deploy instead of brittle manual JSON editing. The skill stresses that `swa-cli.config.json` must come from `swa init`, while `staticwebapp.config.json` remains the place for runtime routing, authentication, headers, and API runtime settings. Local development runs through the emulator with API proxy and auth simulation before cloud push. It also addresses adding Azure Functions backends and wiring GitHub Actions for continuous deployment. Use it when you have a Vite, React, or other static site and want Azure hosting without relearning portal-only workflows.8.7kinstalls112Arch Linux Triagearch-linux-triage is an agent skill that acts as a rolling-release Arch Linux expert for solo builders who run their dev box or small server on Arch. It accepts an optional environment snapshot, a problem summary, and constraints, then produces a disciplined triage narrative instead of random forum commands. Instructions emphasize confirming recent updates, tracing failures with systemd and journals, and fixing issues with pacman-aware remediation. Every major step pairs changes with validation commands and notes when a kernel bump requires reboot. Rollback and cleanup sections reduce the risk of leaving a half-fixed system worse than before. It is for maintainers who need reproducible, copy-paste-ready Arch workflows when updates break boot, networking, or services.8.7kinstalls113Vscode Ext Localizationvscode-ext-localization is an agent skill that walks solo builders and extension authors through Microsoft’s VS Code extension localization model so nothing user-visible ships in English only by accident. It applies when you add or change contributed settings, commands, menus, views, walkthroughs, or runtime messages in extension source code. The skill separates three mandatory tracks: package.json strings via package.nls.LANGID.json, walkthrough body copy in localized Markdown files, and programmatic strings via bundle.l10n.LANGID.json. Each track must stay aligned whenever you introduce or edit copy, which is why the skill stresses updating every existing locale in the same change. For indie developers publishing marketplace extensions to global audiences, following these paths avoids broken command labels, untranslated settings descriptions, and inconsistent walkthrough experiences. It pairs naturally with extension scaffolding and release prep rather than replacing formal translation workflows or CI validation of locale completeness.8.7kinstalls114Breakdown Epic Archbreakdown-epic-arch is an agent skill that formalizes how a solo builder or small team converts an Epic-level Product Requirements Document into a durable technical architecture specification. The prompt positions the agent as a senior architect who must respect a modern TypeScript SaaS stack: Next.js with the App Router, Turborepo monorepo boundaries, tRPC for end-to-end type-safe APIs, Stack Auth for identity, and Docker for every service whether you target self-hosted or multi-tenant SaaS. The deliverable is not scattered chat notes but a single Markdown document under docs/ways-of-work/plan with an epic-named folder, including an architecture overview and a comprehensive Mermaid diagram spanning user layers, services, and integrations. Because it stops at specification and pseudocode, it fits the gap between approved product scope and ticket-level implementation plans. Indie founders use it to keep epics aligned with modular domain-driven boundaries before agents or engineers write features.8.7kinstalls115Finalize Agent PromptFinalize-agent-prompt is an agent skill that acts as an editor for AI prompt files you already drafted. Solo builders maintaining Claude Code skills, Copilot custom instructions, or reusable agent roles use it when a prompt works conceptually but reads rough, inconsistent, or unlike proven templates you have shipped before. The workflow is strict: no file, no work—you must supply the markdown prompt. Then the agent reads it holistically and improves hierarchy, phrasing, and organization while keeping YAML front matter, encoding, and section semantics intact. It explicitly hunts clarity and grammar issues without rewriting your goals. That makes it valuable across the journey whenever you touch agent definitions: tightening a new skill before commit, refreshing docs-adjacent prompts, or standardizing tone before handoff to teammates. It is meta tooling—not code generation—optimized for durable procedural instructions agents actually follow.8.7kinstalls116Fluentui BlazorFluentui-blazor is a reference agent skill for solo builders shipping Blazor apps with Microsoft’s Fluent UI stack. It centers on FluentDataGrid, the generic table component for displaying typed row data with declarative column children. You invoke it when you need correct Razor patterns for sortable property columns, formatted dates and currency, ordinal string comparers, and fully custom cells via TemplateColumn. The skill matters because DataGrid APIs are easy to misuse—treating columns as parameters instead of nested components breaks layouts and sorting. It pairs conceptual guidance with copy-paste snippets for Person-style grids, action buttons, and badge status columns so your agent does not hallucinate invalid Fluent UI Blazor markup. Ideal for indie SaaS dashboards, internal tools, and extensions where you want accessible Fluent styling without reading the full component library docs first.8.6kinstalls117Technology Stack Blueprint GeneratorTechnology-stack-blueprint-generator is a comprehensive agent skill for solo builders who inherited or forked a codebase and need trustworthy architectural documentation fast. You point it at a repository and choose variables such as project type, depth level, whether to include versions and licenses, diagram generation, usage patterns, coding conventions, output format, and categorization strategy. It analyzes implementation signals across major platforms—notably .NET, Java, JavaScript ecosystems, React, and Python—and synthesizes a blueprint solo founders can hand to contractors, future-you, or an coding agent as ground truth. Depth scales from basic inventories to implementation-ready templates that preserve consistency when extending the product. This matters during build when docs lag code, during validate when you must understand what you are buying into, and during operate when you refresh stack truth after upgrades. It is generator-style research documentation, not a deploy or test runner.8.6kinstalls118Copilot Instructions Blueprint GeneratorCopilot Instructions Blueprint Generator is an agent skill for solo builders and small teams who want GitHub Copilot to behave like a teammate that has read the repo, not a generic autocomplete engine. You configure high-level knobs—primary technology, architecture style, code-quality priorities, documentation depth, testing expectations, and versioning scheme—then the skill drives generation of a comprehensive copilot-instructions.md anchored in what already exists in the tree. The workflow stresses analyzing real patterns and forbidding guesses about frameworks or versions, which matters when you ship fast with mixed services or legacy modules. Use it when onboarding Copilot on a brownfield project, standardizing contributions across contributors, or refreshing instructions after a major upgrade. The outcome is a durable instruction file Copilot can cite for consistent naming, layering, tests, and stack-specific APIs—reducing review churn and wrong-library hallucinations during everyday feature work.8.6kinstalls119Github Copilot StarterGitHub Copilot Starter is an agent skill that acts as a setup specialist for brand-new repositories: it interviews you for primary language and framework, project shape, ancillary technologies, development strictness, and whether GitHub Actions should receive copilot setup steps. Solo builders use it to avoid blank-slate Copilot drift where every session reinvents conventions. The skill then materializes a complete GitHub Copilot configuration in the right directories, centering on copilot-instructions.md so Copilot reads consistent guidance on every interaction. It is most valuable at the start of a build when you still have freedom to encode naming, stack, and workflow expectations before feature velocity makes retrofits painful.8.6kinstalls120Convert Plaintext To MdConvert Plaintext to Markdown is an agent skill for solo builders cleaning up documentation debt: it converts plain text or generic text-based files into properly formatted markdown either from bespoke instructions, a named documented conversion option, or by mirroring an already-converted reference document. That flexibility matters when you inherit README fragments, internal specs, or export dumps that never lived in git-friendly markdown. The skill emphasizes consistent headings, lists, and conventions across a doc set so agents and humans read the same structure. Use it during Build when docs block onboarding, publishing, or Copilot context quality, and you need repeatable conversion rather than one-off manual retyping.8.6kinstalls121Generate Custom Instructions From CodebaseGenerate Custom Instructions From Codebase is an agent skill for solo builders and small teams who are mid-migration—upgrading a framework, swapping libraries, or refactoring architecture—and need GitHub Copilot to stop suggesting obsolete patterns. You point it at a before state and after state (branches, commits, or tags), choose how wide to scan the tree, and specify what kind of evolution you are documenting. The skill drives analysis of what changed between those references and turns that into precise custom-instructions text Copilot can use to align completions with your new conventions, APIs, and config. That matters when hand-written migration notes drift from the real diff and every AI suggestion reintroduces deleted patterns. Use it when you have two concrete references representing old and new reality, not when you only have a vague “modernize the stack” goal without a target branch or commit.8.6kinstalls122Legacy Circuit MockupsLegacy Circuit Mockups, as represented in its bundled reference material, helps solo builders and hobbyists document classic parallel memory and similar components in a rigorous, datasheet-style format. The sample content walks through an AT28C256-class 256 Kbit EEPROM: organization, buses, endurance and retention figures, package options, and control-pin behavior for chip enable, output enable, and write enable in 8-bit micro systems. If you are restoring retro hardware, teaching embedded fundamentals, or sketching memory maps for a personal FPGA or emulator project, this skill gives your agent a repeatable outline instead of free-form wiki notes. It is niche relative to typical SaaS stacks and does not replace official manufacturer PDFs for electrical limits or timing diagrams—you still verify absolute maximum ratings and AC characteristics from the vendor. Use it when clarity of pin function and memory geometry matters more than cloud deployment diagrams.8.6kinstalls123Create Technical SpikeCreate Technical Spike is an agent skill from awesome-copilot that generates time-boxed spike documents for critical technical questions you must answer before development proceeds. Solo builders use it when choosing between APIs, proving performance assumptions, or clearing architecture unknowns without diving straight into code. The skill defines a consistent markdown structure—summary, primary and secondary research questions, timebox, and decision deadline—and instructs the agent to create one file per spike in a folder such as `docs/spikes`. That pattern matches common agile spike practice while giving your coding agent a repeatable artifact to fill in during Validate and early Build. It pairs well with planning skills once spikes close and you have enough evidence to write an implementation plan.8.6kinstalls124Power Bi Dax OptimizationPower BI DAX Optimization is an agent skill that acts like a senior DAX reviewer for solo and indie builders who own their own semantic models and reports. When a measure feels slow, fragile, or impossible to explain in a stand-up, you paste the formula and get a structured pass across performance hotspots, naming and comments, best-practice compliance, and maintainability risks. It is aimed at people shipping SaaS or internal analytics on Power BI who do not have a dedicated BI engineer on call. Use it during Grow when dashboards lag, before investor-facing metrics go live, or when you inherit someone else's calculation soup. The outcome is clearer, faster DAX you can defend in documentation and reuse across visuals—not a one-off chat tweak that regresses on the next refresh.8.6kinstalls125Azure Resource VisualizerAzure Resource Visualizer is a documentation-oriented agent skill for indie builders and small teams who already run workloads in Azure and need a readable picture of what is deployed—not another portal click-through. You supply resource group context (and the agent fills inventory, diagram, and narrative sections from your Azure metadata). The output follows a consistent architecture brief: overview, tabular inventory, Mermaid diagram, then relationship detail across networking, data paths, managed identities, Key Vault access, RBAC, and dependency order, closing with recommendations. That structure helps when onboarding a contractor, preparing an incident runbook, or validating that production matches what you think you shipped. It does not provision resources by itself; it organizes and explains what exists. Pair it with live `az` or portal verification because stale SKUs or renamed resources will flow through whatever data you provide.8.6kinstalls126Repo Story TimeRepo Story Time is an agent skill for solo builders who inherit repos, join a fork, or need to explain a codebase fast without days of manual reading. It follows a fixed methodology: explore structure and key config files, then synthesize two markdown files—a technical REPOSITORY_SUMMARY.md and a narrative THE_STORY_OF_THIS_REPO.md grounded in commit history. The skill explicitly requires creating real files in the repository root, which makes the output citable for README links, investor data rooms, or team onboarding. It spans multiple journey moments: validating what you bought or forked, building while documenting decisions, and operating when you hand off maintenance. Expect shell-driven discovery plus semantic search, so it suits agents with filesystem and git access in a full clone.8.6kinstalls127Create Github Issues For Unmet Specification RequirementsCreate GitHub Issues for Unmet Specification Requirements is an agent skill for solo and indie builders who keep requirements in spec documents and need the gap to implementation reflected in GitHub without manual triage. You point the agent at a specification file; it analyzes requirements, checks the codebase and related files under `/spec/`, searches existing issues to prevent duplicates, and opens a separate issue for each requirement that is not implemented. Issues are formatted with requirement IDs in titles, detailed descriptions, implementation notes, labels such as feature and enhancement, and acceptance criteria aligned to the `feature_request.yml` template when available. It fits teams shipping SaaS, APIs, or CLIs where specs drive delivery and Copilot or Claude Code has GitHub tool access. Use it after a spec is written or updated—not as a substitute for writing the spec itself.8.6kinstalls128Suggest Awesome Github Copilot SkillsSuggest Awesome GitHub Copilot Skills is an agent skill that acts as a curator for the official awesome-copilot catalog. It pulls the published skills list, inventories what you already have under `.github/skills/`, fetches upstream SKILL.md content for version comparison, and recommends additions that fit your repository and conversation—while calling out outdated local copies. Indie builders use it when standing up agent workflows in Build, refreshing skill packs before a Ship hardening pass, or pruning stale instructions during Operate. The process assumes network access to GitHub raw URLs and structured use of a fetch tool, so it suits teams that treat skills as versioned dependencies rather than one-off prompts. It complements Prism-style discovery by focusing narrowly on the github/awesome-copilot monorepo.8.6kinstalls129What Context NeededWhat Context Needed is a journey-wide agent skill that stops your assistant from guessing when a question depends on code you have not shared yet. You supply your question via a placeholder; the skill instructs the model to enumerate required and helpful file paths, justify each choice, note what is already in context, and surface uncertainties. Solo builders use it across Idea research, Validate scoping, Build debugging, Ship review, and Operate incident triage whenever a wrong answer would waste time or break production. The deliberate pause—context list first, answer second—mirrors how senior engineers ask what to open in the IDE before opining. It is lightweight meta guidance with no external fetches, so it drops into any skills folder alongside domain-specific workflows.8.6kinstalls130Create Github Issue Feature From Specificationcreate-github-issue-feature-from-specification is a workflow skill that converts a local specification path into a well-formed GitHub feature issue. Indie builders who keep specs in markdown or structured files use it to avoid manually copying requirements into GitHub and to prevent duplicate tickets when several agents or teammates touch the same idea. The skill enforces a short ritual: extract requirements from the file, search existing issues, then create or update using the repository’s feature_request.yml template when available. Titles reflect the feature name; descriptions carry problem statement, solution, and context. It is ideal when a spec is ready for implementation tracking but not yet broken into PR-sized tasks—pair it with your planning skills upstream and implementation skills downstream.8.6kinstalls131Terraform Azurerm Set Diff Analyzerterraform-azurerm-set-diff-analyzer is a reference skill that embeds AzureRM Provider Set-type attribute definitions as structured JSON for Terraform resources such as azurerm_application_gateway. Solo and indie builders shipping on Azure use it when authoring or reviewing Terraform so they understand which nested blocks Terraform compares as sets and which fields act as the identity key. That clarity reduces noisy plans, unexpected destroys, and hours lost debugging provider behavior. It complements—not replaces—the official registry docs by concentrating on set semantics across many resources in one agent-readable catalog. Reach for it during module design, before large refactors, or when a plan shows unexpected changes on nested blocks you thought were in-place updates.8.6kinstalls132Workiq CopilotWorkIQ Copilot guides agents on using Microsoft’s WorkIQ CLI and MCP server (Public Preview) to pull live Microsoft 365 intelligence into coding and planning tasks. Instead of guessing stakeholder intent from local files alone, you can summarize Sarah’s budget emails, list this week’s meetings, fetch Q4 planning documents, recap today’s Engineering Teams messages, or see who owns Project Alpha. Setup covers installing the Copilot CLI plugin from github/copilot-plugins, alternatively running the global npm package or MCP mode, and completing tenant administrator consent for EULA and permissions. Solo builders on small teams still benefit when they wear PM and eng hats and need org context inside the agent session. Use it whenever repository context is insufficient and your work lives in M365.8.6kinstalls133Csharp Nunitcsharp-nunit is an agent skill that encodes NUnit best practices for .NET unit testing, from project layout through data-driven cases. Solo builders shipping C# APIs, CLIs, or SaaS backends use it when agents generate tests that would otherwise mix concerns, skip fixtures, or ignore idiomatic naming. The skill steers toward mirrored test classes, independent idempotent tests, and the minimum assertions needed per behavior. It also documents when to use inline TestCase data versus TestCaseSource for larger matrices. Invoke it while implementing features in Build if you test as you go, or concentrated in Ship before a release when hardening coverage—either way you get consistent dotnet test–ready suites without re-explaining NUnit rules in every session.8.6kinstalls134Update Markdown File IndexUpdate Markdown File Index is an agent skill for solo builders and small teams who maintain living documentation in git. You point it at a markdown file and a folder (plus an optional file pattern); the agent reads the doc structure, lists matching files, and either refreshes an existing index block or adds a new section as a bullet list or table. That removes hand-editing every time you add a skill, prompt, or example file to a catalog-style repo. It fits Claude Code, Cursor, and similar agents that can read the filesystem and edit markdown. Use it when onboarding contributors need a trustworthy file map, when awesome-list or monorepo docs drift from reality, or before a launch when you want an accurate inventory without running a separate doc generator. Complexity is beginner-friendly: no external APIs, mainly scan-and-format discipline.8.6kinstalls135Mcp Deploy Manage AgentsMCP Deploy Manage Agents is an agent skill aimed at builders and admins operating inside Microsoft 365 tenants who need to publish, assign, and govern MCP-based declarative agents—not at typical solo hackers shipping a side project on Vercel alone. The skill encodes how organization-published agents differ from creator-shared, Microsoft, partner, and frontier agents, and steers an agent through deployment and management in the M365 admin center with compliance and assignment semantics. Solo indie readers may still use it when their day job is tenant Copilot rollout or when they consult on enterprise agent governance. Pair it with MCP server skills only after you know which agent type and approval path your org requires. Expect intermediate complexity: tenant policies, admin roles, and Studio versus Builder provenance all matter.8.6kinstalls136Java Refactoring Remove ParameterJava Refactoring Remove Parameter is a focused agent skill for solo builders and small teams maintaining Java backends who want consistent application of Fowler’s Remove Parameter without guessing at ripple effects. The skill supplies concrete before-and-after method pairs—such as dropping an isCloud argument when ConnectContext already carries cluster semantics—so your coding agent mirrors proven edits across callers and executors. Use it during feature cleanup when boolean parameters proliferate, when consolidating master and follower node logic, or when reducing API surface before a release. It is intermediate: you still need tests and compile checks after signature changes. It does not replace a full static analysis suite; it standardizes one refactor move with exemplars your agent can generalize.8.6kinstalls137Code Exemplars Blueprint GeneratorCode Exemplars Blueprint Generator is a meta skill that assembles a technology-agnostic prompt for scanning a codebase and producing exemplars.md: curated file references and optional snippets that embody your team’s patterns. Solo builders and small teams use it when onboarding an agent to an unfamiliar repo, kicking off a refactor, or documenting de-facto standards without hand-picking every file. You set primary stack, analysis depth, how categories are grouped, caps per category, and whether snippets and commentary appear. The skill does not run the scan itself—it outputs the instruction block your coding agent executes. That makes it ideal for Claude Code, Cursor, or Codex workflows where procedural prompts replace one-off chat. Pair it with your existing lint or review skills so exemplars inform later PR review rather than replacing tests.8.6kinstalls138Copilot Cli QuickstartCopilot CLI Quickstart is an agent skill that turns GitHub Copilot CLI into a friendly terminal tutor for solo builders who have never used the product or want a refresher. It is not a generic Claude or Cursor guide—it assumes Copilot CLI tooling and documentation fetch hooks. Tutorial mode walks through lessons when you say "start tutorial" or "next lesson"; Q&A mode answers targeted questions such as what /plan does or how to mention files; reset mode clears tutorial state when you want a clean run. On first tutorial use it routes you to a Developer or Non-Developer track so examples match your background. The skill celebrates small wins and explains rationale before mechanics, which lowers anxiety for builders who usually avoid the shell. Install it when you are adopting Copilot CLI as your primary coding agent interface and want structured onboarding instead of ad-hoc doc hopping.8.6kinstalls139Structured Autonomy PlanStructured Autonomy Plan is a planning-only agent skill that collaborates with you to design a development plan without writing code. It assumes the entire effort ships as one pull request on a dedicated branch and breaks work into commits that are individually testable milestones. Step one mandates autonomous context gathering through a runSubagent call following an embedded research guide; if that tool is missing, the agent executes the same guide with ordinary tools and stops further tooling when the subagent path succeeds. Step two classifies simplicity versus complexity to decide one consolidated commit versus a multi-step sequence. Step three emits a draft from a fixed output template, persists it under plans/{feature-name}/plan.md, surfaces clarifying questions for ambiguous sections, and pauses for your feedback before any implementation. Solo builders use it to avoid half-baked specs and to give coding agents a commit order they can follow literally.8.6kinstalls140Php Mcp Server GeneratorPHP MCP Server Generator is an agent skill that interviews you for project name, server description, transport type (stdio, HTTP, or both), desired tools, whether to include resources and prompts, and PHP version, then materializes a complete PHP Model Context Protocol server using the official PHP SDK. Output follows a conventional layout with composer.json, entry server.php, categorized src classes, and a starter ToolsTest.php. It targets solo builders who want agent-callable capabilities in PHP without hand-rolling SDK boilerplate, Composer autoload rules, or transport wiring. The skill emphasizes production-ready structure—gitignore, README, provider hooks—so you can extend tools incrementally and point Claude Desktop, Copilot, or other MCP clients at your server. Use it when PHP is your stack and you need a typed, testable MCP surface instead of a one-off script.8.6kinstalls141Quasi CoderQuasi-Coder is a journey-wide agent skill that positions the model as a senior implementer who can read imperfect inputs—shorthand, pseudo-code, natural language with typos, or semi-technical bullet lists—and ship production-quality code that matches the underlying intent. Solo builders use it when a cofounder, client, or past self left notes that are directionally right but not compilable. The skill explicitly covers delimiter-wrapped shorthand segments and mixed-language pseudo-code, making it useful across Validate prototypes, Build features, and Ship hotfixes when the spec arrived in chat form. It does not replace formal design review or test-driven specification; it closes the gap between messy human description and working software when you need speed without misreading the ask.8.6kinstalls142Comment Code Generate A TutorialComment Code Generate a Tutorial is an agent skill for solo and indie builders who have a working Python script but need it to look professional and teachable. The skill walks the agent through a fixed three-part ritual: refactor the code to standard Python practices and PEP 8, weave clear instructional comments that explain why each section exists, and produce a polished README.md with overview, setup, logic breakdown, usage example, and optional sample output. It fits the Build phase when you are documenting internal tools, open-sourcing a utility, or preparing coursework-style repos without hiring a technical writer. The outcome is a beginner-friendly project package that reads well on GitHub and in agent-assisted walkthroughs, without replacing formal API reference generation for large libraries.8.6kinstalls143Power Bi Model Design ReviewPower BI Model Design Review is a comprehensive checker skill that turns your coding agent into a data modeling reviewer for Power BI semantic models. Solo builders who own both the warehouse ETL and the PBIX layer use it when a dataset grows past a few tables and relationships start to blur grain or filter context. The prompt frames assessment across schema architecture, relationship design, performance, and maintainability—with explicit checkboxes for star schema compliance, hidden keys, bidirectional filters, and bridge tables for many-to-many. It fits Grow analytics as the primary shelf because the payoff is trustworthy measures for retention, revenue, and ops dashboards, but it also helps during Build when you first shape facts and dimensions and during Ship review before publishing datasets to production workspaces. Invoke it with model metadata, relationship diagrams, or table lists rather than expecting automatic .pbix parsing unless your agent has separate file tools.8.6kinstalls144Mkdocs TranslationsMkDocs Translations is an agent skill for solo builders and small teams running MkDocs who need a full English documentation tree copied into another locale without manually touching dozens of markdown files. The workflow starts by locking the target language and locale code, then systematically inventories docs/docs/en and docs/docs/includes/en, translates each file in order, and keeps going until the queue is empty—explicitly forbidding stop-and-ask loops mid-run. It preserves Markdown structure and directory layout so nav and includes keep working once MkDocs config reflects the new language paths. Best after your English docs are stable; it is not a substitute for legal or marketing transcreation review before Launch in non-English markets.8.5kinstalls145Create Tldr Pagecreate-tldr-page is a documentation generator skill for solo builders who want terminal-friendly command references without rereading long vendor manuals. It enforces the tldr-pages format: short description, example invocations, and flags distilled from an official URL (and optional context files). The agent must obtain both a command identifier and a documentation link—if either is missing, it guides you to supply them rather than hallucinating syntax. When a URL needs retrieval, it can apply fetch tooling first; when content lives in a local file, it treats embedded URLs as the source of truth and asks you to pick among multiples. Ideal while documenting CLIs you depend on in a monorepo, preparing contributor onboarding, or seeding internal cheat sheets before launch. It does not replace reading security-sensitive flags (rm, cloud IAM, prod deploy). Intermediate comfort with markdown and CLI ecosystems helps; output is ready for PR into a tldr-pages fork or your docs tree.8.5kinstalls146Update Llmsupdate-llms is an agent skill for solo builders who treat repository documentation as a product surface for LLMs, not just humans. It maintains the root llms.txt file so models know where specifications, architecture notes, and authoritative guides live—following the llms.txt standard at llmstxt.org. The workflow starts by reading the current file and spec, then diffing against live repo structure to catch new folders, retired paths, and relocated specs before editing. Use it after meaningful doc reorganizations, when you add ADRs or API contracts, or before launch when you want AI search and coding agents to cite the right entry points. It spans Launch visibility and ongoing Operate iteration because stale llms.txt silently misroutes agents. You need a git checkout with an existing or intended llms.txt; the skill analyzes rather than inventing fantasy directories. Pair with human README updates and optional sitemap or SEO work for full discoverability.8.5kinstalls147First AskFirst Ask is a journey-wide agent skill for solo builders who want agents to stop guessing and start aligning. Powered by Joyride’s interactive input tool, it treats every assignment as a refinement ritual: understand objectives, ask targeted questions, explore the codebase or the web when needed, split work into steps, and simplify the mental model until it is actionable. Only after the human confirms there is no further input does the agent present a plan and proceed. It fits greenfield features, ambiguous bugs, refactors, and ops tasks equally—anywhere rushing to code would waste tokens or ship the wrong thing. It complements planning skills by front-loading clarity rather than producing a full implementation spec alone. Install it when your default agent behavior is “do first, ask later” and you want a consistent pre-flight checklist across Claude Code, Cursor, and similar hosts that support Joyride-backed tooling.8.5kinstalls148Swift Mcp Server GeneratorSwift MCP Server Generator is a build-phase agent skill that turns a natural-language request into a complete Swift package for a Model Context Protocol server. It follows the official MCP Swift SDK layout: entrypoint, server wiring, modular tool/resource/prompt definitions and handlers, XCTest scaffold, and README. Solo builders on Apple platforms use it to expose domain logic to Claude Code, Cursor, or other MCP clients without hand-rolling protocol boilerplate. The templates emphasize production-shaped separation of concerns and logging dependencies suitable for local CLI or embedded app hosts. Intermediate complexity assumes Swift Package Manager fluency and a machine with Swift 6. Invoke when you already know what capability the server should expose and need a consistent starting tree rather than architectural debate.8.5kinstalls149Bigquery Pipeline AuditBigQuery Pipeline Audit is an agent skill for solo builders and small teams shipping Python pipelines against BigQuery. It walks the codebase like a senior data engineer, hunting runaway query loops, missing byte caps, duplicate SQL in one run, and unbounded external spend before a scheduled job empties the wallet. The response follows a fixed outline from cost exposure through idempotency, observability, and operational guardrails, always citing concrete functions and lines and recommending minimal patches. Use it when a notebook script is about to become a nightly job, after a cost spike, or when reruns might double-load partitions. It pairs naturally with backend build work and operate monitoring but lives on the ship/review shelf because its deliverable is a gate-ready report, not greenfield codegen. Intermediate complexity assumes comfort reading `google-cloud-bigquery` patterns and job config objects.8.5kinstalls150Containerize AspnetcoreContainerize ASP.NET Core is an agent skill for solo and indie builders who already have a .NET web API or SaaS backend and need a production-minded Linux Docker setup without hand-rolling every layer. You supply basic containerization settings—project path, target framework, distro, and optional tuning— and the skill focuses exclusively on changes required for the app to run in a container, not unrelated refactors. It is aimed at developers shipping on Azure, Kubernetes, or any registry-backed host who want Debian, Alpine, Ubuntu, chiseled, or Mariner-based images with sensible defaults when fields are left blank. Use it during Ship when launch prep blocks you on Dockerfile drift, multi-stage builds, or picking a base image for .NET 8 versus 9. The outcome is customized Dockerfile and companion ignore-file guidance so your agent can produce repeatable images you can build, scan, and deploy in CI.8.5kinstalls151Power Bi Performance TroubleshootingPower BI Performance Troubleshooting is an agent skill that acts as a performance specialist for models, reports, and DAX-heavy datasets when a solo builder or tiny team cannot afford opaque “slow dashboard” tickets. It opens with problem definition and scope—whether pain is refresh, page load, visuals, queries, capacity, or connectivity—and whether impact is broad or filter-specific. You then collect baselines against stated targets (for example sub-10-second pages and sub-3-second visual interactions) before walking a structured diagnosis path through model and report layers. It fits operators and analyst-founders who own both semantic models and published reports without a dedicated BI platform team. Use it when Grow analytics workloads spike memory or CPU, or when Operate iteration is blocked waiting on refresh windows. The skill produces classification, measured baselines, and actionable remediation guidance rather than ad-hoc tuning guesses.8.5kinstalls152Go Mcp Server GeneratorGo MCP Server Generator is an agent skill for indie builders who want a credible Model Context Protocol server in Go without copying fragmented blog snippets. It specifies a complete module tree—entrypoint, tools and resources packages, configuration loader, tests, and documentation—wired to the official go-sdk. The generator insists on multiple real tools with typed contracts, transport setup, signal-aware shutdown, and error handling patterns suitable for small teams shipping agent integrations. Use it in Build when you need a CLI-adjacent or API-backed tool surface for coding agents, internal ops, or product automation. Compared to hand-rolling main.go, it enforces structure so you can iterate on business logic instead of MCP boilerplate. Deliverables are a buildable Go project you can publish, containerize, and register with your agent host.8.5kinstalls153Suggest Awesome Github Copilot Agentssuggest-awesome-github-copilot-agents helps solo builders treat GitHub’s awesome-copilot repository as a living parts catalog for Copilot Custom Agents. The skill mandates a disciplined process: pull the authoritative agent list from README.agents.md, inventory what you already store under `.github/agents/`, read local front matter for descriptions, then pull matching files from raw.githubusercontent.com to diff versions. That comparison step matters for indies who copied agents months ago and never rebased on upstream fixes. It also uses repository context and recent chat to recommend agents you have not adopted yet, reducing duplicate boilerplate and spotlighting gaps in your agent toolchain. This is narrowly about Copilot agent files—not general MCP servers or Claude skills—so it shines when you standardize on GitHub Copilot in VS Code or compatible hosts. Expect network fetches and filesystem reads; you still choose what to copy or update.8.5kinstalls154Gen Specs As Issuesgen-specs-as-issues is a product-manager-style agent skill from the awesome-copilot collection that walks a solo builder through understanding an existing repo and writing honest specs for what is still missing. It starts with documentation, tests, and main entry points so you grasp purpose and patterns, then contrasts claimed capabilities with placeholder or partial code to surface real gaps along the user journey. The workflow is deliberately systematic rather than a one-shot feature brainstorm: you answer guiding questions, focus on broken or missing core steps first, and land on a prioritized list you can turn into implementation issues. It fits indie builders who inherited a half-built SaaS, CLI, or API and need a disciplined backlog before agents start coding. Use it when docs oversell reality or when you cannot tell which modules are stubs. Pair the output with strict implementation skills so agents execute only what the specs describe.8.5kinstalls155Csharp Mstestcsharp-mstest is an agent skill that teaches solo and indie builders how to write effective C# unit tests with modern MSTest (3.x/4.x). It covers project layout (`[ProjectName].Tests`), NuGet and MSTest.Sdk setup, sealed test classes, AAA structure, and readable test names. The skill favors current APIs—`[TestMethod]`, constructors for setup instead of `[TestInitialize]` when possible, and `[TestCleanup]` when teardown must run on failure—and points you at `dotnet test` for fast feedback. Use it when you are shipping a .NET service, library, or CLI and want consistent test style without hunting scattered blog posts. It does not replace integration or E2E test stacks; it sharpens the unit-test layer so agents and humans produce maintainable assertions and data-driven cases aligned with MSTest analyzers.8.5kinstalls156Structured Autonomy Implementstructured-autonomy-implement is a discipline-first coding skill for solo builders who already invested in a written implementation plan and need an agent that will not improvise. It encodes Structured Autonomy: pick up the next unchecked step, complete every item in the current step, mark progress in the plan document itself, verify with the tests or builds named in the plan, and yield control when the plan says STOP. If the user forgets to attach the plan, the agent refuses to code—a deliberate guardrail against scope creep in autonomous sessions. This pairs naturally with planning and spec skills that produce checkbox plans rather than vague prompts. It is less about architecture creativity and more about faithful, auditable execution across frontend, backend, or CLI repos. Treat it as the downstream muscle once gaps are specified and tasks are ordered.8.5kinstalls157Suggest Awesome Github Copilot InstructionsSuggest Awesome GitHub Copilot Instructions is a workflow skill for solo and indie builders who want Copilot to follow repo-specific rules without manually browsing the awesome-copilot catalog. It pulls the authoritative instruction list from GitHub, inventories what you already have under `.github/instructions/`, and compares each local file to the upstream version so you see gaps, staleness, and overlap. Recommendations are grounded in current repository context and recent chat, which helps small teams avoid piling on redundant guidance or missing domain packs they actually need. The process is explicit: fetch catalog, scan locally, extract descriptions, fetch remotes, then compare. Use it when onboarding a project to Copilot, after cloning a template, or whenever instruction drift causes inconsistent completions. It does not replace writing custom instructions—it accelerates adoption of community-maintained patterns while keeping your tree honest and up to date.8.5kinstalls158Fabric Lakehousefabric-lakehouse is an agent skill that helps solo builders and small data teams implement Microsoft Fabric lakehouse patterns end to end. It explains how Data Factory orchestrates ETL and ELT with copy activities, Dataflow Gen2, Spark notebooks, conditional branches, and lakehouse maintenance for Delta tables. The skill documents a medallion-style Daily_ETL_Pipeline—metadata checks, per-file bronze ingestion, silver transforms, gold aggregations, then optimize/vacuum—and includes Spark configuration snippets such as parquet V-Order and optimizeWrite. Use it when you are building a analytics backend on OneLake rather than wiring a generic Postgres API. It complements Fabric docs with opinionated pipeline shapes agents can reproduce in notebooks and pipeline JSON. Expect Python/Spark familiarity and a Fabric workspace before invoking.8.5kinstalls159Copilot Usage Metricscopilot-usage-metrics is an agent skill for retrieving and presenting GitHub Copilot usage data using the GitHub CLI and REST-backed scripts in the skill folder. Solo builders and small-team leads use it when they need answers about how many people use Copilot, suggestion acceptance, chat volume, or per-user breakdowns—for an organization or an entire enterprise, aggregated or per seat, for a specific calendar day or recent activity. The skill walks the agent through choosing org vs enterprise, asking for slugs when missing, and executing `get-org-metrics.sh`, `get-org-user-metrics.sh`, or the enterprise equivalents. It is operational analytics for AI coding tools, not a replacement for GitHub’s admin UI or billing exports. Pair it with proper `gh auth` and permissions before running in CI or shared agents.8.5kinstalls160Tldr Prompttldr-prompt is an agent skill for solo builders who need fast, scannable takes on GitHub Copilot customization files, MCP server write-ups, or documentation linked from a URL. Instead of skimming long READMEs during a session, you point the agent at a file, selection, or link and get a tldr-pages-style markdown summary rendered directly in chat. It enforces a required input source, classifies the artifact type, extracts representative examples, and follows the template structure so the result reads like a cheat sheet you can act on immediately. It fits whenever you are onboarding to a new prompt pack, comparing agent modes, or wiring an MCP tool and want prose trimmed to patterns and commands. The skill is documentation transformation only—it does not persist pages to disk—so it pairs well with discovery in early phases and ongoing reference during build and ship.8.5kinstalls161Dataverse Python QuickstartDataverse Python Quickstart is an agent skill for builders integrating Microsoft Dataverse using the official Python SDK preview. It produces concise, copy-ready snippets: package install, client construction with InteractiveBrowserCredential, everyday CRUD, bulk create and update paths, and retrieve-multiple with paging parameters. Optional coverage for uploading to File columns stays within documented preview capabilities so you do not depend on undocumented APIs. Solo developers use it when a SaaS or internal tool must read and write Power Platform tables from Python automation or a small API layer, especially after validate scope locks Dataverse as the system of record. The skill favors official example shapes over framework-heavy scaffolding, which speeds first connection and leaves room for your own error handling and deployment story on Azure or elsewhere.8.5kinstalls162Csharp Tunitcsharp-tunit is an agent skill that encodes TUnit best practices for solo and indie .NET builders who want modern unit tests without dragging xUnit habits into the wrong framework. It walks through project setup in a dedicated `[ProjectName].Tests` assembly, class naming aligned to production types, and SDK workflows using `dotnet test`. The skill emphasizes one-behavior-per-test methods, clear Arrange-Act-Assert structure, and TUnit’s hook model for test, class, assembly, and session scopes. Assertion guidance centers on TUnit’s fluent `await Assert.That()` API rather than classic attribute-heavy styles. It also covers data-driven scenarios so you can parameterize inputs without bloating individual test methods. Use it when your agent keeps generating xUnit facts, missing hooks, or assertions that do not match TUnit 8.x expectations.8.5kinstalls163Model Recommendationmodel-recommendation is an agent skill for solo builders who maintain GitHub Copilot chat modes and prompt files and want defensible model picks instead of always defaulting to the newest flagship. You supply a path to an .agent.md or .prompt.md file and optionally your subscription tier; the skill infers task complexity, capability needs, and cost sensitivity, then ranks suitable models from Copilot’s catalog including GPT-5 variants, Claude Sonnet and Opus lines, Gemini, Grok Code Fast, and reasoning models like o3 and o4-mini. It also accounts for tier limits—Free users on 0x models only versus Pro and Pro+ premium allotments—and references auto-selection behavior in VS Code. Use it when shipping a specialized agent, tightening spend on high-volume prompts, or matching reasoning depth to debugging versus codegen workloads.8.5kinstalls164Winapp Cliwinapp-cli is an agent skill that teaches coding agents to use Microsoft’s Windows App Development CLI when a solo builder targets desktop Windows. It covers initializing projects and SDK channels (stable, preview, experimental), generating or editing manifests, creating and signing MSIX packages, running packaged apps for debugging, unregistering test installs, publishing toward the Microsoft Store, and driving UI through Microsoft UI Automation. Prerequisites assume Windows 10+ with WinGet, npm, CI action, or manual release installs. The skill is framework-agnostic beyond Windows: .NET csproj flows differ slightly (no winapp.yaml), while Electron, Rust, Tauri, and Flutter paths share the same packaging and identity concepts. Expect a public-preview CLI whose flags may shift—agents should follow the command table and verify against current Microsoft docs before production releases.8.5kinstalls165Typespec Api Operationstypespec-api-operations is an agent skill that walks solo and small-team builders through adding RESTful operations to an existing TypeSpec API plugin for Microsoft 365 Copilot. It targets the moment you already have a plugin scaffold and need concrete GET, POST, PATCH, and DELETE endpoints with `@route`, query and path parameters, and optional Adaptive Card visualization for list and detail experiences. The readme emphasizes practical snippets—list-all, filter-by-query, get-by-id—and shows how to pair `@card` metadata with a JSON card under `appPackage`. For indie builders shipping Copilot extensions or internal agents on M365, this reduces guesswork around Copilot-specific decorators and card wiring so the agent can extend the spec without breaking plugin packaging conventions.8.5kinstalls166Structured Autonomy Generatestructured-autonomy-generate is an agent skill that converts a complete PR or feature plan already stored as plan.md into implementation-ready markdown for solo builders who want agents to execute without ambiguity. It reads the feature name, branch, numbered steps, and file lists, runs comprehensive codebase research once through a subagent without pausing mid-flight, then fills a strict plan template with concrete paths, full code blocks, per-item checkboxes, and observable verification criteria. The intended flow is structured autonomy: the human approves plan.md first; the skill produces implementation.md that downstream coding agents can follow line by line. It fits indie teams using plan folders per feature and pairs naturally with skills that author the initial plan before this generator runs.8.5kinstalls167Transloadit Media Processingtransloadit-media-processing helps solo builders offload heavy file transforms to Transloadit instead of hand-rolling ffmpeg scripts in every feature branch. The skill maps common product asks—HLS or MP4 encoding, poster frames, animated previews, responsive images, audio extractions, clip concatenation, captions, document OCR, and chained multi-robot pipelines—to Transloadit’s cloud execution model. It explicitly covers when to reach for the skill versus ad-hoc scripts, and points to two integration paths: the @transloadit/mcp-server for agent-driven IDE workflows and the @transloadit/node CLI for scripted deploys. With 86+ robots referenced in the catalog framing, it acts as a decision guide and integration checklist rather than a single-format recipe. Use it while building upload flows, creator tooling, or content moderation features that need repeatable, scalable media operations.8.5kinstalls168Polyglot Test Agentpolyglot-test-agent is an agent skill for solo builders who need reliable unit test coverage without manually researching framework idioms in every language they touch. It activates when you ask to generate tests, improve coverage, create test files, or test specific code, then runs a coordinated Research → Plan → Implement pipeline where a top-level test generator delegates to specialized agents. The research phase captures project conventions and dependencies; planning chooses files and cases; implementation writes tests meant to compile and pass rather than hollow stubs. It spans backend services, CLIs, and polyglot monorepos common to indie stacks. Use it during hardening before ship, after major features land in build, or when refactoring legacy modules that lack guardrails.8.5kinstalls169Mcp Create Adaptive Cardsmcp-create-adaptive-cards is an agent skill for solo builders shipping MCP-backed API plugins into Microsoft 365 Copilot. It walks through when to use fixed static templates versus dynamic templates that branch on response shape, and how to declare those in ai-plugin.json under response_semantics. You learn to bind tool outputs to Adaptive Card 1.5 layouts so budgets, lists, and other structured API data appear as readable cards instead of raw JSON in chat. The skill fits indie teams extending internal APIs to Copilot without building a separate Teams app UI. It assumes you already have or are generating an MCP API plugin and need visual response templates next. Complexity is intermediate because manifest semantics, JSONPath-style paths, and Adaptive Card authoring overlap. Use it during build when integration work is the bottleneck for Copilot-ready demos.8.5kinstalls170Java Mcp Server Generatorjava-mcp-server-generator is an agent skill that emits a complete Java Model Context Protocol server layout so solo builders do not hand-roll package structure, handler splits, and build files from sparse docs. It standardizes com.example.mcp-style packages for tools, resources, and prompts, plus configuration and a test entry point. You can target Maven or Gradle and optionally Spring Boot for shops already on that stack. The skill fits Build when your agent product needs custom tools callable from Claude Code, Cursor, or other MCP clients. Intermediate complexity comes from reactive streams idioms in the Java SDK and correct capability registration. After generation you still implement business logic in handlers and harden auth and deployment separately. Pair it with validation and ship-phase testing before exposing network-facing transports.8.5kinstalls171Fedora Linux Triagefedora-linux-triage is an agent skill that acts like an on-call Fedora specialist for solo builders running VMs, homelab servers, or CI runners on Red Hat’s community distro. You supply a problem summary and optionally release and constraints; the skill returns a numbered triage plan, remediation commands, verification steps, and rollback guidance. It emphasizes Fedora-native tooling rather than generic Linux guesses, which matters when SELinux denials or firewalld rules are the real root cause. Intermediate complexity reflects that misapplied fixes can worsen boot or network state. Use it in Operate when logs are noisy, services won’t start, or package conflicts block deploys. It does not replace full infrastructure-as-code for fleet management—it accelerates one-machine diagnosis and recovery.8.5kinstalls172Dataverse Python Usecase BuilderDataverse Python Usecase Builder is an agent skill for solo builders and small teams who need Microsoft Dataverse solutions without guessing schema or SDK patterns. When you describe a business need—customer documents, bulk sync, scheduled jobs, or compliance-heavy updates—the skill acts as a solution architect for the Power Platform Dataverse client SDK. It walks through requirement analysis (operations, data volume, cadence, latency, error tolerance, audit), then proposes tables, relationships, and custom fields, and generates implementation-ready Python with logging, retries, and performance notes. It fits agents in Claude Code, Cursor, or Codex that already target Power Platform or Dynamics-style backends. Use it during scoping conversations that are ready to commit to a data model, not for one-line API trivia. The output is a documented architecture plus code components you can adapt into services, automation, or internal tools.8.5kinstalls173Mcp Create Declarative AgentMCP Create Declarative Agent is a generator-style skill for solo builders and small teams shipping inside the Microsoft 365 ecosystem. It walks you through creating a declarative Copilot agent that talks to a Model Context Protocol server so Copilot can reach your APIs, databases, or custom tools with proper authentication. You scaffold via Microsoft 365 Agents Toolkit, add an MCP action pointing at your server, choose which tools to expose, and configure OAuth 2.0 or SSO before reviewing the generated manifest and plugin JSON. The output aligns with Teams app packaging and API plugin patterns, which matters when you need repeatable agent setups instead of one-off prompt hacks. Use it when you already have or plan an MCP server and want Copilot users to invoke those capabilities inside M365 with governed auth and explicit tool allowlists.8.5kinstalls174Sponsor FinderSponsor Finder helps solo maintainers and indie OSS authors see who actually maintains the libraries under their GitHub project and whether those people accept sponsorship. You pass a repository as owner/repo or `/sponsor expressjs/express`; the skill detects the package ecosystem from manifests, pulls the full dependency graph in one deps.dev call, maps versions to GitHub repos, enriches unique projects with OSSF Scorecard signals, and hunts funding links from npm metadata, FUNDING.yml, and search—with every URL fetched to confirm it works. The report groups direct and transitive dependencies so you can prioritize sponsors for critical transitive packages, not just headline dependencies. Use it when operating an open repo, preparing a sustainability plan, or before a dependency audit conversation with users or investors.8.5kinstalls175Create Spring Boot Kotlin ProjectCreate Spring Boot Kotlin Project is a generator-style agent skill that walks a solo builder through verifying Java 21, curling the Spring Initializr template with opinionated reactive dependencies, and unpacking a Gradle Kotlin jar project locally. It is aimed at indie developers who want a production-shaped API skeleton without hand-picking a dozen starters in the browser. Invoke it when you are starting a new backend service and already have Docker and Docker Compose available for local data dependencies. The flow emphasizes shell commands you can audit—version check, parameterized start.spring.io POST, unzip, cleanup—so the agent does not improvise project layout. Custom naming flows through artifactId and packageName parameters in the download step. Compared to vague “make me a Spring app” prompts, this skill encodes Spring Boot 3.4.x, Kotlin, and reactive data access defaults that match many SaaS API prototypes.8.5kinstalls176Power Apps Code App ScaffoldPower Apps Code App Scaffold is an integration-focused agent skill that acts as an expert Power Platform developer to lay down a complete Code Apps project: Vite and React on the mandated port 3000, TypeScript settings aligned with the Power Apps SDK, and PAC CLI initialization for power.config.json metadata. Solo builders use it when they have validated a low-code or citizen-dev gap but need a code-first SPA that still participates in Entra-backed connector ecosystems. The skill enumerates essential artifacts—vite.config tuned for Code Apps, a React PowerProvider wrapper, package dependencies, and PAC-driven registration steps—so agents do not omit preview-platform constraints. It suits indie consultants and product teams shipping internal tools or customer portals that must call Dataverse, SQL, or SaaS connectors without rebuilding auth plumbing. Invoke after environment access to PAC CLI is confirmed; expect iterative connector configuration rather than a single file dump.8.5kinstalls177Java Add Graalvm Native Image SupportJava Add GraalVM Native Image Support is a workflow-oriented agent skill that embeds GraalVM native compilation into existing Java projects. It inspects pom.xml or Gradle files, classifies Spring Boot, Quarkus, Micronaut, or plain Java stacks, injects the GraalVM Native Build Tools configuration, and drives repeated native builds while interpreting failures—reflection, resource, and classpath issues included. Solo builders who need smaller containers, faster cold starts, or edge-friendly binaries use it after core features exist but before aggressive Ship perf work. The skill explicitly mirrors an expert agent loop: analyze, configure, build, fix, repeat until green. It pairs naturally with backend APIs and CLIs where JVM startup cost matters. Advanced familiarity with profiles, native-image metadata, and CI resource limits helps; the agent should not treat native image as a one-shot Gradle flag.8.4kinstalls178Cosmosdb Datamodelingcosmosdb-datamodeling is an agent skill that walks solo and indie builders through Azure Cosmos DB NoSQL modeling as a guided expert session. You start by surfacing application requirements—queries, write paths, scale, and concurrency—and the skill captures them in cosmosdb_requirements.md. It then translates those constraints into a Cosmos-native design in cosmosdb_data_model.md using stated best practices and common patterns, so you avoid retrofitting partition strategy after launch. The workflow is intentionally conversational but bounded: the skill limits how many questions it asks at once so you are not stuck in endless discovery. When you signal extreme throughput or “massive scale,” it pivots early to binning, chunking, and minimizing real write operations. Use it when you are choosing NoSQL on Azure, refactoring a hot container, or aligning API shapes with how data will actually be read and written.8.4kinstalls179Declarative AgentsDeclarative Agents is a development kit skill for solo builders and small teams shipping Microsoft 365 Copilot declarative agents. It organizes work into three workflows: a fast path for prototypes, an enterprise path for production constraints, and validation-oriented steps so manifests stay schema-correct before you test in Agents Playground or ship via the Agents Toolkit. You define purpose, users, and capabilities, then produce either JSON manifests or TypeSpec that compiles to JSON, with explicit guidance on capability combinations and toolkit hooks. Use it when you are committing to M365 Copilot as a distribution channel and need repeatable structure instead of copying partial samples from docs. It matters because Copilot agent schemas and capability rules change often; a procedural kit reduces rejected manifests and rework before tenant deployment.8.4kinstalls180Shuffle Json DataShuffle JSON Data is a procedural skill for developers who need to anonymize order or reduce repetition in JSON arrays without breaking syntax or schema. The agent acts as a cautious data engineer: it refuses to shuffle until it confirms every object shares the same property names (unless variables say otherwise), escalates when nesting makes default shuffling unsafe, and only then applies Fisher-Yates-style randomization at the object level. Solo builders use it when generating varied demo datasets, stress-testing parsers, or preparing training-like fixtures where row order must not leak labels. It is narrow by design— not a general ETL pipeline—but that focus prevents the common failure mode of shuffled keys or half-updated nested blobs.8.4kinstalls181Kotlin Mcp Server Generatorkotlin-mcp-server-generator is a generator skill for solo builders who want a production-shaped Model Context Protocol server in Kotlin without reverse-engineering SDK samples. It emits a standard Gradle multi-file tree—entrypoint, server bootstrap, configuration, and a tools package—wired to the official io.modelcontextprotocol:kotlin-sdk plus Ktor and kotlinx libraries. You get multiple example tools with typed inputs and outputs, exception handling, and a minimal test harness using coroutines, plus a README that explains how to build and run. Invoke it when you are extending Claude Code, Cursor, or Codex with JVM-native integrations where Kotlin’s type safety and Gradle ergonomics beat a throwaway script. The skill optimizes for copy-paste-ready structure so you can rename packages, swap tool logic, and register transports without rebuilding the skeleton from docs.8.4kinstalls182Mcp Copilot Studio Server GeneratorMCP Copilot Studio Server Generator is a build-phase skill for solo developers shipping tools into Microsoft Copilot Studio via Model Context Protocol. It walks the agent through producing a complete server plus connector assets that respect Copilot Studio’s strict OpenAPI-like constraints—primitive-only fields, no reference types in tool I/O, and full URIs on endpoints—while implementing the streamable MCP profile agents expect. You use it when you already know which tools the model should call and need a scaffold that will not be silently filtered at import time. The skill explicitly documents which MCP surfaces Copilot Studio supports today, so you do not waste cycles on prompts or resource patterns that cannot be reached. Outcome is a deployable starting point you can extend with business logic and hosting.8.4kinstalls183Typespec Create Agenttypespec-create-agent helps solo builders and small teams produce a complete TypeSpec declarative agent for Microsoft 365 Copilot without hand-assembling decorators from scattered docs. The skill targets a single main.tsp that declares the agent identity, long-form behavioral instructions, conversation starters that showcase real tasks, and capability hooks such as web search, SharePoint, Teams messages, mail, people lookup, Python code interpretation, image generation, Graph connectors, or Dataverse—chosen to match your scenario. Character limits are enforced in the template guidance so submissions pass Microsoft constraints the first time. Use it when you are turning an internal workflow or customer-facing assistant idea into something Copilot can load, test, and iterate on inside a Microsoft 365 tenant. It is definition-focused: you still handle tenant deployment, governance, and connector URLs outside the generated TypeSpec.8.4kinstalls184Typespec Create Api Plugintypespec-create-api-plugin is a generator skill for solo and indie builders shipping Microsoft 365 Copilot extensions. It tells your coding agent exactly how to lay out TypeSpec: an agent namespace in main.tsp that imports actions, declares the Copilot agent name and instructions, and binds operations; and a separate actions.tsp service namespace with REST routes, query/path parameters, response models, and M365 Copilot action descriptors. You reach for it when you already have—or are defining—a REST API and need a consistent plugin skeleton instead of hand-copying decorators and imports. It matters because Copilot plugins expect specific TypeSpec packages and patterns; getting the file split and decorators right early avoids rework at registration and testing time. Pair it with your API design and deployment steps once the generated files are reviewed and filled with real endpoints.8.4kinstalls185Azure Resource Health Diagnoseazure-resource-health-diagnose is a workflow skill for solo builders and tiny teams running workloads on Azure who need a disciplined way to answer “is this resource healthy and why not?” instead of random CLI spelunking. It sequences retrieval of Azure diagnostic best practices, resource discovery when you only have a name, and analysis of logs and telemetry through Azure MCP tools—with CLI only when MCP is unavailable. Prerequisites are explicit: configured authenticated Azure MCP, an identified target resource, and something actually running enough to produce signals. Use it in Operate when incidents or drift show up, during Ship when a staging deploy looks unhealthy, or in Build when you are validating integration environments. The outcome is an evidence-backed remediation plan you can execute or hand to an agent for the next infra change steps, not a single ad-hoc metric pull.8.4kinstalls186Power Platform Mcp Connector SuitePower Platform MCP Connector Suite is a generator skill for solo builders and small teams who want Microsoft Copilot Studio agents to call external capabilities through Model Context Protocol without hand-writing every Swagger edge case. It assembles the full custom-connector package: OpenAPI definition with the MCP streamable agentic protocol annotation, connector metadata and authentication properties, and C# transformation script tuned for JSON-RPC over HTTP. The skill encodes what Copilot Studio actually supports today—tools the model can invoke with approval and resources exposed as tool outputs—while flagging unsupported prompt templates so you do not bake in dead paths. Validation and troubleshooting sections focus on real rejection reasons, especially reference types and composite schemas that break agentic import. Use it when you already have or plan an MCP server and need a Power Platform–legal connector surface. It is Microsoft-stack specific and intermediate in complexity because authentication, policy, and deployment still sit outside the generated files.8.4kinstalls187Az Cost OptimizeAzure Cost Optimize is an agent workflow skill for solo and indie builders who already run workloads on Azure and want structured savings work instead of ad-hoc console clicking. It starts by pulling current optimization best practices through the Azure MCP server, then discovers what you actually deployed—either from Infrastructure-as-Code in the repo or from resources in a named resource group. Analysis is grounded in those practices and general Azure guidance so recommendations are explainable, not vague “turn it off” hints. The deliverable model is built for real execution: each finding becomes its own GitHub issue, and a single EPIC ties the set together so you can prioritize, assign, and close savings like a mini backlog. You need Azure and GitHub MCP configured, a target repo for issues, and optionally IaC for richer context. It fits builders shipping SaaS or APIs on Azure who own their own cloud bill and want agent-assisted FinOps that leaves an audit trail in GitHub.8.4kinstalls188Containerize Aspnet FrameworkContainerize ASP.NET Framework is a generator-style skill for indie builders maintaining older ASP.NET applications on .NET Framework who need Windows Docker images without accidentally applying Linux or .NET Core templates. The workflow is driven by containerization settings you fill in up front: path to the .csproj, Windows Server image flavor (Core or Full), and OS version, with sensible bracketed defaults for everything else. The agent focuses only on what must change for the app to run inside a Windows container—IIS, framework targeting, and Windows base images—rather than refactoring the codebase to modern .NET. That narrow scope reduces risk for brownfield sites where a full migration is out of scope but repeatable deploys matter. Use it when you are preparing to ship to container hosts or internal registries that expect Windows workloads. Intermediate complexity reflects IIS, binding, and Framework servicing knowledge you still need to validate locally. Pair with your CI registry and host docs after files are generated.8.4kinstalls189Centos Linux Triagecentos-linux-triage is an agent skill that acts as a CentOS Linux expert for indie operators running VMs, bare metal, or legacy RHEL-compatible stacks. You supply an optional CentOS version, a problem summary, and constraints; the skill confirms Stream versus legacy assumptions, then walks through systematic diagnosis with systemd and journal tooling before proposing fixes. Remediation steps are written as ready-to-run command blocks, each paired with validation checks so you know the change actually stuck. SELinux denials and firewalld rules are explicitly considered because those are the usual gaps between “it works on Ubuntu” tutorials and a real CentOS box. Rollback and cleanup guidance closes the loop when a change makes things worse. Use it when you are the on-call engineer for a small SaaS or API and need firefighting playbooks without opening ten Stack Overflow tabs.8.4kinstalls190Entra Agent Userentra-agent-user is an agent skill for solo builders shipping Microsoft-centric AI workers that must behave like people in the tenant—not just headless apps. It walks through creating agent users in Microsoft Entra Agent ID so your automation receives user-class tokens and can reach services that reject pure application principals. The skill stresses prerequisites easy to get wrong: an agent identity blueprint-backed ServiceIdentity parent, correct Graph permissions, and verification that the parent is #microsoft.graph.agentIdentity—not a standard app registration. That boundary matters when you want mailboxes, Teams, or other M365 surfaces that orgs expose only to user identities. Expect advanced Azure AD vocabulary, role requirements like Agent ID Administrator, and architecture notes rather than a five-minute copy-paste snippet. Use it during Build when you are past the prototype and need production-grade identity for an agent product inside a customer’s Entra tenant.8.4kinstalls191Csharp Mcp Server Generatorcsharp-mcp-server-generator is an agent skill that walks a solo builder through creating a production-shaped Model Context Protocol server in C#. It specifies project structure, prerelease NuGet dependencies, stderr-only logging (critical for stdio transports), and the modern .NET generic host with automatic tool registration from the assembly. You get concrete patterns for attributed tool classes, described parameters, and async handlers so Claude Code, Cursor, or Codex can call your capabilities reliably. It fits indie builders who already ship on .NET and want custom MCP tools without reverse-engineering SDK samples. Use it when you need a repeatable bootstrap rather than one-off chat snippets—especially before wiring domain APIs into your agent workflow.8.4kinstalls192Update Avm Modules In Bicepupdate-avm-modules-in-bicep is an agent skill for solo builders maintaining Azure infrastructure as code with Azure Verified Modules. It scans a target Bicep file for avm/res module references, resolves latest versions from Microsoft Container Registry tag APIs, and applies semver-aware updates while surfacing breaking changes from the bicep-registry-modules documentation. The workflow favors agent tools for search, fetch, file edits, and command execution, then proves compliance with bicep lint and build. It suits indie operators who want repeatable module hygiene without manually tracking dozens of AVM releases. Expect approval gates when parameter contracts shift—non-breaking progress updates only until you confirm risky jumps.8.4kinstalls193Ruby Mcp Server Generatorruby-mcp-server-generator is an agent skill that emits a complete Ruby Model Context Protocol server using the official mcp gem. It defines Gemfile dependencies, Rake tasks, a bin launcher, modular tool and prompt classes, optional resources, and Minitest stubs so a solo builder can ship agent-callable capabilities quickly. The layout mirrors common Ruby gem practices—frozen string literals, lib namespacing, and rubocop-ready tests—making it easier to grow from sample greet and calculate tools into real domain integrations. Use it when your stack is Ruby and you want parity with C# or TypeScript MCP scaffolds without reading SDK READMEs line by line. Output is meant to run locally and plug into stdio-based agent hosts after you customize tools and secrets handling.8.4kinstalls194Create Oo Component Documentationcreate-oo-component-documentation is an agent skill that inspects object-oriented source at a path you provide and drafts comprehensive, standardized documentation aligned with C4 Model levels, Arc42, IEEE 1016, and agile “just enough” principles. Solo and indie builders use it when a module has grown past inline comments but still lacks a shareable design description for collaborators, open-source readers, or their own future sessions. The skill distinguishes folder versus file inputs, traces class structures and dependencies, names creational/structural/behavioral patterns, and documents method contracts and quality attributes where the code supports inference. It fits the Build phase most often but also supports Ship review prep and Operate handoffs when you are refreshing maintainer docs after refactors. Output is structured narrative and reference material rather than user-facing marketing or automated test reports.7kinstalls195Mcp Configuremcp-configure is a guided Copilot skill for connecting Microsoft Dataverse to GitHub Copilot through MCP. It walks you through choosing whether the server should be available globally or only in the current repo, then reads and updates the appropriate JSON configuration with HTTP MCP entries. Solo builders and small teams on Power Platform or Dataverse-backed products use it when agents need live org data instead of pasted schema screenshots. The flow emphasizes discovering already-configured servers, deriving the correct org-scoped server identifier, and writing durable config paths on disk. It is narrowly scoped to Dataverse MCP for Copilot—not generic MCP authoring for every host—and assumes you can supply or confirm your environment URL. Successful runs leave Copilot able to reach your registered endpoint on the next session refresh.7kinstalls196Update Oo Component DocumentationUpdate OO Component Documentation is an agent skill that takes an existing object-oriented component doc and rewrites it to reflect the codebase as it exists today. Solo maintainers and small teams use it after refactors so C4-style context, container, and component narratives do not drift from classes, inheritance, and public APIs. The workflow begins from `${file}`, pulls `component_path` from front matter when present, and applies a numbered standards checklist (DOC-001 through DOC-005) plus structured analysis steps (ANA-001 through ANA-007) for patterns, interfaces, and dependencies. It targets developers and future maintainers rather than marketing copy, emphasizing architectural documentation templates over minimal inline comments. Invoke when a component grew new design patterns or breaking API surface and your Arc42 or IEEE-aligned doc is stale. It complements code review and ship-time quality gates by making documentation a deliberate update pass, not an afterthought.7kinstalls197Create Web FormCreate Web Form is an agent skill for solo builders who need production-minded HTML forms—not just static inputs but validation, accessibility, styling, and server processing. It activates when you ask to create a contact form, signup form, or any data-handling web form, and it points the agent at structured references for UI styling, ARIA guidelines, JavaScript validation, PHP and Python handlers, database integration, and secure network patterns. The skill is intentionally reference-heavy so agents do not invent one-off validation or accessibility mistakes common in indie launches. Use it during frontend build work when you want consistent patterns across MySQL-backed submits, REST endpoints, or XML exchanges. It does not replace threat modeling for public endpoints or legal consent copy for regulated data; pair it with your stack's auth and spam controls. Complexity spans beginner-friendly markup through intermediate server wiring.7kinstalls198Datanalysis Credit RiskDataanalysis Credit Risk is an agent skill package oriented at solo builders and small teams building lending, BNPL, or internal risk analytics who need a repeatable variable-selection pass instead of one-off notebooks. It wires together pandas cohort cleaning, PSI-style stability thinking, toad-oriented screening, LightGBM training with sklearn metrics, and Excel deliverables so an agent can document which months were dropped and which features survived basic quality gates. Install it when you already have a labeled target column and monthly partitions and want the agent to enforce minimum bad-count and volume rules before modeling. It matters because bad cohorts and unstable features are the fastest way to ship a scorecard that fails validation; this skill encodes that gate as procedural steps rather than chat improvisation. Pair it with your own data pipeline and compliance review—the skill does not replace legal or model-risk sign-off.7kinstalls199Msstore CliMicrosoft Store Developer CLI (msstore) is an agent skill that teaches coding agents how to operate Microsoft’s Store publishing toolchain end to end. Solo Windows indie developers use it when Partner Center tasks should be scripted: registering API access, listing owned apps, inspecting submission state, pushing a build live, configuring package flights, or wiring GitHub-style CI/CD so every release does not depend on manual portal clicks. The skill spans many app stacks—Windows App SDK and WinUI, UWP, .NET MAUI, Flutter, Electron, React Native, and PWA—so the agent can stay on CLI verbs instead of guessing portal navigation. Prerequisites are explicit: Partner Center permissions, Azure AD app registration with API access, and .NET 9 runtime on the developer OS. It fits builders who already have a shippable binary and need repeatable Store operations rather than greenfield UI coding.6.8kinstalls200Suggest Awesome Github Copilot PromptsSuggest Awesome GitHub Copilot Prompts is an agent skill for solo and indie builders who standardize GitHub Copilot with the community awesome-copilot catalog instead of writing every prompt from scratch. It walks a fixed process: pull the authoritative prompt list and descriptions from awesome-copilot, inventory what already lives under `.github/prompts/`, read local front matter, and byte-compare each file to the matching raw GitHub version so you see what is current versus stale. It then weighs repository signals—languages, frameworks, contribution guides, and recent chat themes—to propose net-new prompts you do not already have and prioritized updates where upstream changed tools or wording. Recommendations are formatted as scored tables with install paths and rationale, which makes it practical when you are bootstrapping agent ergonomics on a new codebase or doing a periodic hygiene pass before a release. It assumes Copilot-style prompt files and network access to GitHub; it does not replace writing custom prompts for proprietary domains.6.8kinstalls201Import Infrastructure As CodeImport Infrastructure as Code is an agent skill for solo builders and small teams who inherited or grew Azure environments without maintained Terraform. It drives a disciplined path from az discovery through AVM-aligned module selection, import block generation, and dependency ordering so live state matches code before you refactor. The emphasis on Verified Modules reduces bespoke azurerm_resource sprawl that drifts on the next portal change. Inputs are flexible—subscription or resource group—with prerequisites of authenticated Azure CLI and Terraform on PATH. Use when stakeholders ask to codify what is already deployed, prepare acquisitions, or enable GitOps without greenfield guesswork. Advanced operators benefit most; beginners should pair with Azure IAM basics. Deliverables are reviewable .tf trees plus import instructions aimed at a clean plan, not a one-shot apply mandate.6.6kinstalls202Mentoring JuniorsMentoring Juniors is a journey-wide agent skill that installs a Socratic mentoring methodology under the Sensei persona for junior developers and people new to AI-assisted coding. Instead of delivering patches or final explanations, it responds with structured questions, hints, and pseudocode nudges so the learner owns the reasoning path. Solo builders benefit when they are mentoring interns, leveling up on unfamiliar stacks, or catching themselves asking the model to “just fix it” and wanting a healthier habit. The skill activates on a large phrase list—from “what does this error mean” through “overwhelmed” and slash commands like /concept—making it easy to invoke during Build debugging, Ship review prep, or Operate incident learning. It pairs well with formal planning skills only after the learner has tried articulating the problem; it deliberately is not a code generator or security auditor.6.5kinstalls203Noob ModeNoob Mode is an awesome-copilot skill that reframes GitHub Copilot CLI permission dialogs so non-engineers and cautious solo builders understand every tool request before typing y or n. Without it, prompts look like opaque “Allow tool: edit on path …” strings; with it, the agent explains the action in plain language, ties it to the user’s last request, labels risk, and states what happens on approve or decline. Use it whenever you delegate file reads, edits, or other gated tools across Idea research notes, Build implementation, Ship review fixes, or Operate incident edits—the pattern is the same at every phase. It does not disable approvals or auto-run tools; it only changes how requests are presented. Ideal for lawyers, founders, and indie hackers who want agent speed without blind consent. Install alongside your normal Copilot skills; no separate MCP server required.6.2kinstalls204Web CoderWeb Coder is an Awesome Copilot agent skill that positions your assistant as a senior web engineer fluent from document semantics through transport and security layers. Solo builders invoke it whenever work touches HTML, CSS, JavaScript, browser APIs, HTTP or HTTPS behavior, web security controls, performance optimization, or accessibility compliance. It emphasizes accurate terminology, modern standards, and practical patterns for both client and server-side web concerns rather than a single framework fad. Because the web surface spans the whole product lifecycle, the skill is journey-wide: you can use it while scaffolding UI in Build, hardening CORS and CSP before Ship, tuning cache headers for Launch SEO and perf, or debugging fetch failures in Operate. Complexity is intermediate to advanced depending on how deep you go into protocols and security. It is editorial knowledge embedded in the agent, not an MCP server or code generator by itself.5.6kinstalls205Winmd Api Searchwinmd-api-search is an agent skill that helps solo and indie builders—and small teams on Windows—find the correct desktop platform API before writing code. It queries a local cache of WinMD metadata from the Windows Platform SDK, bundled WinAppSDK/WinUI baselines, any restored NuGet packages that ship `.winmd` files, and build-output WinMD from your own class libraries. That coverage means you can look up namespaces, classes, interfaces, and enums with accurate signatures even on a fresh clone where you have not yet restored or built. Use it whenever a user asks how to implement a platform feature, which control or API to pick, or what members exist on a WinRT type. It reduces wrong-namespace guesses and outdated docs drift when agents generate WinUI, C#, or C++/WinRT code. Prerequisites are a .NET SDK; the skill is procedural research, not a hosted MCP server.5.5kinstalls206Winui3 Migration GuideWinUI 3 Migration Guide is a reference skill for solo builders and small teams moving Universal Windows Platform apps to WinUI 3 and the Windows App SDK—or for anyone auditing AI-generated C# XAML that still imports legacy namespaces. It organizes the mechanical work: namespace rewrites, dispatcher and windowing API swaps, and feature areas like dialogs, pickers, share targets, printing, and background tasks, with before-and-after snippets. Prism places it on Build → Frontend because the value is correcting UI and platform calls during implementation, not distribution or store launch. Use it when migration docs are scattered or when Copilot keeps emitting UWP patterns. Intermediate complexity: you should already have a WinUI 3 project skeleton and know which files you are porting.5.4kinstalls207Azure PricingAzure Pricing is an agent skill that equips solo and indie builders with Microsoft Copilot Studio billing vocabulary and unit economics when they plan conversational agents or Microsoft 365–connected copilots. It consolidates cached rate snapshots for classic and generative answers, agent actions, deep reasoning triggers, tenant-wide Graph grounding, flow actions, and basic through premium text or generative-AI tool tiers, always steering you to fetch live rates from Microsoft Learn and the official usage estimator when network access is available. Use it while validating whether a topic design, RAG grounding strategy, or premium model tier fits your budget before you wire flows in Power Platform. The skill matters because agent bills compound on messages, actions, and pages—not a flat SaaS seat—and underestimating grounding or premium tool tiers can erase margins on small products. It is reference-oriented procedural knowledge for Claude Code, Cursor, and similar agents, not a deploy or infra automation skill.4.4kinstalls208Copilot SpacesCopilot Spaces is an agent skill for working with GitHub Copilot Spaces—shared collections of repositories, files, documentation, and instructions that ground model responses in what your team actually maintains. Solo builders and tiny teams using GitHub Copilot can invoke it when someone says “use our Copilot space,” wants to discover available spaces, or needs answers tied to curated internal docs instead of generic training data. The skill documents two integration paths: read-only MCP tools to list spaces and pull full space context by owner and name, and write operations through the GitHub REST API using gh api when you need to create, update, delete spaces, or manage collaborators. That split matters in practice: discovery and chat grounding are fast via MCP; governance and setup stay in gh. Use it during Build while implementing features, during Ship when review conversations need the same canonical docs, and during Grow when content and support material live in a shared space. It is an integration skill for the GitHub Copilot ecosystem, not a replacement for local CLAUDE.md or Cursor rules—best when your source of truth already lives on GitHub.4.1kinstalls209Flowstudio Power Automate Mcpflowstudio-power-automate-mcp is the plumbing skill for talking to Power Automate through FlowStudio’s MCP server. Solo and indie builders who automate business processes with Copilot-class agents install it first so auth, helpers, and tool discovery work the same way every session. It does not carry the full narrative for building or fixing flows—that lives in companion skills—but every specialized workflow assumes this foundation is already loaded. You get guidance on FlowStudio subscription requirements, discovering available MCP tools, and handling oversized responses cleanly. Use it whenever you connect an agent to Power Automate rather than guessing endpoints or reimplementing auth in each chat. After this skill, load flowstudio-power-automate-build for creation, flowstudio-power-automate-debug for failures, or Pro+ monitoring and governance skills for production discipline.4kinstalls210Doublecheckdoublecheck is an agent skill from GitHub’s awesome-copilot collection that turns vague “is this true?” anxiety into a repeatable verification report. It instructs the agent to extract discrete claims from whatever text you designate—landing page hero stats, competitive research notes, investor one-pagers, or blog drafts—then rate every claim using five confidence buckets from VERIFIED through FABRICATION RISK. Solo builders wear marketing, product, and support hats; one bad citation in launch copy or a shaky TAM number in a validate memo can waste weeks. This skill surfaces disputed and high-risk items up front, documents what was searched when evidence is thin, and gives actionable recommendations such as verifying in a primary database or removing unsourced figures. It is not a lawyer or a live fact-check API; it structures agent-driven web research and skepticism. Use it when scope documents cite market data, when growth content makes comparative claims, or before ship when legal-adjacent assertions appear in user-facing strings. Intermediate complexity reflects the need to judge which sources count and to iterate on flagged claims.3.1kinstalls211Secret ScanningSecret Scanning is an agent skill that packages GitHub’s secret scanning reference for solo builders shipping code on GitHub. It explains how user alerts appear in the Security tab, how push-protection bypasses become trackable alerts with explicit resolution states, and why partner alerts never show in your repo but may revoke credentials at the provider. Use it when you need to classify an alert, choose a safe remediation path, or wire automation against the alerts API instead of treating every leak as a generic CVE. For indie teams without a dedicated AppSec person, the skill turns opaque GitHub security UI into actionable steps: validate the secret, rotate if live, mark false positives with justification, and document test fixtures. It pairs naturally with Dependabot and broader ship checks but does not replace org-level secret scanning policies or custom pattern authoring—those still live in GitHub settings.3.1kinstalls212DependabotDependabot is an agent skill that gives solo builders a precise reference for GitHub Dependabot configuration instead of copy-pasting half-working YAML. It walks the required top-level `version: 2` layout, the `updates` list with `package-ecosystem`, `directory`, and `schedule`, and optional `registries` for private feeds plus `multi-ecosystem-groups` when you want one schedule across Rust and Docker, for example. Invoke it when you are standing up automated dependency PRs on a new SaaS or CLI repo, splitting monorepo paths per ecosystem, or tuning interval and grouping so you are not drowned in daily npm bumps. The skill is reference-heavy: it helps you pick the correct ecosystem string for Bun, Bazel, devcontainers, dotnet-sdk, and the rest, and avoid invalid combinations that silently fail in Actions. It does not run Dependabot for you—that remains GitHub—and it is not a substitute for reviewing breaking major upgrades or running your test suite on each PR.3.1kinstalls213Security ReviewSecurity Review from GitHub Awesome Copilot is a focused agent skill that gives solo builders and small teams a repeatable way to catch common application-security mistakes in modern JavaScript ecosystems. After resolving review scope in Step 1, the skill loads language-specific vulnerability pattern guidance so the agent knows which APIs and framework defaults are high risk—eval and dynamic code execution, command injection via child_process, path traversal via filesystem calls, missing Express hardening, CORS that reflects arbitrary origins, React XSS sinks, and Next.js Server Actions or API handlers that skip authentication and HTTP method validation. The intent is not to replace professional penetration testing or supply-chain tooling, but to embed OWASP-flavored checklist thinking into the same sessions where you already ask an agent to read a diff. It fits indie SaaS and API projects where one developer wears security hat at merge time and needs concrete grep-level cues instead of generic “be careful” advice.3kinstalls214Eval Driven DevEval-driven-dev is an agent skill from the awesome-copilot collection that implements the opening step of eval-driven development: deep project analysis before you touch code layout, entry points, or instrumentation. Solo and indie builders shipping AI features, agents, or automation should install it when they want benchmarks that reflect how the product is actually used—not generic pass/fail checks. The skill directs you through README, docs, and top-level source to answer what the software does, who uses it and why, and a concrete capability inventory (modes, features, and user journeys). That inventory becomes the backbone for which entry points to prioritize, what eval criteria to define, which trace inputs to record, and how to structure dataset entries. Because quality means something different for a voice FAQ agent than for a research synthesizer or a scraping toolkit, the analysis step prevents wasted instrumentation on the wrong surfaces. Use it in Validate when scoping what to prove, in Build while designing agent tooling and observability, and in Ship when hardening test and eval pipelines. It pairs naturally with skill-creator-style measurement workflows once criteria2.9kinstalls215Autoresearchautoresearch turns vague optimize this requests into a disciplined autonomous experimentation loop for solo builders who already use git-backed repos. The agent first walks you through Setup: goal, how success is measured, and boundaries on what may change. Only then does it enter a Karpathy-inspired loop that edits code, runs commands, reads measurements, and commits or reverts outcomes without waiting for step-by-step approval. That model fits performance tuning, algorithmic tweaks, configuration sweeps, and other tasks where pass or fail is numeric or benchmark-shaped rather than subjective. The skill is MIT-licensed and expects terminal access plus a git repository, which matches how indie developers ship on a single machine. It deliberately refuses one-shot bug fixes and review-only work, so you reach for it when you can name the metric and afford multiple automated attempts. Prism lists it under operate iterate because the value compounds after initial ship, even though validation prototypes and ship perf work benefit from the same loop.2.4kinstalls216Premium Frontend UiPremium Frontend UI is a GitHub Awesome Copilot skill that trains the agent to architect immersive, high-performance web experiences instead of defaulting to bland layouts. It defines how to establish a creative foundation—choosing a strong visual identity such as editorial brutalism, organic fluidity, or cyber-technical dark UI—before writing components. Solo builders use it when they need marketing sites, portfolios, or product shells that feel deliberate: advanced motion, typographic scale, glassmorphism or grid brutalism as appropriate, and interaction depth without sacrificing load behavior. It complements functional feature work by raising the bar on aesthetic cohesion and craft. Invoke when a page or component must read as premium rather than bootstrap-generic, especially under tight indie timelines where one agent session must deliver both structure and visual intent.2.2kinstalls217Automate ThisAutomate This is an agent skill that takes a screen recording of tedious manual work and turns it into understandable steps plus targeted automation. It begins by verifying ffmpeg is installed—required—and optionally Whisper when the recording includes narration, surfacing install hints only when checks fail. The agent extracts frames and audio from the video, rebuilds what the user did and why, then proposes scripts at several complexity tiers grounded in what is already on the machine rather than mandating a cloud SaaS. Solo builders use it to eliminate copy-paste rituals across spreadsheets, admin UIs, file moves, and repetitive CLI sequences. It fits whenever you can demonstrate the process once on video and want an agent to own the analysis and first-pass script, with you reviewing commands before execution.2kinstalls218NapkinNapkin is an Awesome Copilot agent skill that turns Copilot CLI into a visual collaboration loop for solo builders and stakeholders who think better on a canvas than in chat alone. When you invoke it, the agent copies a bundled HTML whiteboard to your Desktop, opens it in your browser, and explains how to share results back. You draw, annotate, and arrange sticky notes while the skill stays jargon-light for lawyers, PMs, and business partners—not only engineers. After you capture the board, Copilot reads the PNG (and optional structured data) and continues conversationally with critique, options, and follow-ups. Use it during early discovery, scope conversations, or anytime you need a shared picture before committing to build or ship work. It is local-first static HTML on the Desktop, not a hosted whiteboard SaaS.1.8kinstalls219Cloud Design Patternscloud-design-patterns packages reference architecture guidance from awesome-copilot so solo builders and small teams can name tradeoffs instead of reinventing integration shapes. It walks patterns such as the Anti-Corruption Layer—façade translation between legacy and modern models—and Backends for Frontends, where separate APIs serve web versus mobile clients without duplicating core business logic. Gateway Aggregation and companion entries give implementation considerations: translation cost, service sprawl, shared services between BFFs, and when to retire adapters after migration completes. Use it while validating whether a SaaS or API product needs multiple client surfaces, during Build when sketching service boundaries, and at Ship when reviewing whether a proposed gateway or BFF actually reduces coupling. The skill is declarative knowledge, not an IaC generator; pair it with your cloud provider docs and deployment skills.1.8kinstalls220Cli MasteryCLI Mastery is an interactive training skill for GitHub Copilot CLI aimed at solo and indie builders who want reliable habits instead of guessing at slash commands. It walks through slash-command categories one at a time with concrete examples and when-to-use notes, then validates mastery with a randomized ten-question final exam that requires at least eighty percent correct answers to earn the CLI Wizard title. The material ties together project initialization, MCP configuration, adding files to context, conversation compaction, and which custom agents are safe to run in parallel. Because it is procedural knowledge about the agent interface itself, it stays relevant whenever you are driving an AI coding session—not only during initial project setup. Use it when you are new to Copilot CLI or when you want a structured refresher before leaning on destructive flags like `--allow-all` or `--yolo`.1.8kinstalls221Draw Io Diagram Generatordraw-io-diagram-generator is an agent skill for solo builders who need professional system architecture visuals without becoming diagram specialists. It instructs the agent to produce draw.io-compatible mxfile XML—swimlanes, tiers, connectors, titles, and optional Cisco network glyphs—with sensible defaults for page size, grid, and styling. Use it during Build when documenting how services connect, during Ship when reviewers need a single picture of blast radius, or during Operate when you refresh infra maps after changes. The skill reduces the friction of blank-canvas diagramming in GitHub Copilot-style workflows and keeps diagrams versionable as text. It is especially helpful when you are explaining a solo SaaS or API topology to future-you, collaborators, or AI agents that reason better when structure is explicit.1.8kinstalls222Flowstudio Power Automate BuildFlowStudio Power Automate Build is a connector action-pattern reference for Microsoft Power Automate flows aimed at indie builders and small teams automating SharePoint lists, mail, Teams, and approvals. It supplies ready-made JSON blocks for `OpenApiConnection` actions, including host `apiId`, `connectionName` placeholders tied to `connectionReferences`, and OData parameters such as dataset URLs, list names, filters, and page size. The skill explains how to reference outputs in expressions, inject runtime values into `$filter` with correct OData quoting, and enable pagination when lists exceed single-page limits. Use it when you are drafting or extending cloud flows inside an agent session backed by FlowStudio MCP, so you spend less time hunting official connector shapes and more time shipping reliable automations across your tenant.1.7kinstalls223Issue Fields MigrationIssue Fields Migration is an agent skill that documents GitHub’s org-level Issue Fields REST API for scripting migrations and backfills with the GitHub CLI. It explains how to list field definitions (single select, date, text, number), read current values on an issue, and POST additive updates while respecting the 2026-03-10 API version header. Solo maintainers use it when moving teams from labels-only triage to structured fields, syncing automation, or bulk-updating issues without hand-editing the UI. The skill emphasizes checking existing values before writes and resolving repository_id for write endpoints—a common footgun in migration scripts. It is reference-weighted API prose suited to agent-driven gh one-liners and small migration playbooks, not a full data pipeline product.1.6kinstalls224Flowstudio Power Automate Debugflowstudio-power-automate-debug teaches an agent a structured investigation loop for Power Automate cloud flows using the FlowStudio MCP server. Microsoft Graph often returns only coarse run status, which leaves solo operators and small teams guessing which action failed and why. This skill walks through listing runs, drilling into actions, reading real inputs and outputs, and separating data problems from flow logic bugs. It is aimed at builders who already ship business automations on Power Platform and need fast RCA when schedules, approvals, or child flows break. Prerequisites include FlowStudio MCP connectivity and familiarity with Power Automate concepts—not generic code debugging. Pair it with connection setup from the companion MCP skill before invoking this debug playbook on failed runs or expression errors.1.6kinstalls225CodeqlCodeQL Alert Management Reference is an agent skill for solo and small teams using GitHub code scanning. It documents how CodeQL alerts are classified, how security severity is derived from CVSS and CWE tags, and how standard Error, Warning, and Note levels differ from Critical-through-Low security tiers. Use it when alerts pile up in the Security tab or in pull-request checks and you need consistent triage language instead of guessing impact. The skill is informational procedural knowledge—not a scanner—so it pairs with your existing CodeQL workflows and Copilot-assisted fixes. It matters for indie builders who ship frequently but lack a dedicated AppSec reviewer, because mis-prioritized dismissals create real risk while over-fixing Note-level noise slows shipping. Treat it as the severity and labeling cheat sheet before you bulk-dismiss or open fix PRs.1.6kinstalls226Microsoft Agent FrameworkMicrosoft Agent Framework is a reference skill for solo and indie builders shipping agent features on Microsoft’s stack in either C#/.NET or Python. Invoke it when the target codebase is .NET or Python and you need installation commands, authoritative GitHub paths, and conventions that match how the framework expects agents, workflows, and hosting to be wired. On .NET it steers you toward consistent async agent operations, type-safe service registration, configuration, and authentication aligned with standard hosting. On Python it reinforces async throughout agent and workflow code plus explicit, typed interfaces even in dynamic modules. The skill does not replace reading current samples—it tells you where to verify patterns before introducing orchestration or new APIs. It pairs naturally with Claude Code, Cursor, or Codex when you are building internal copilots, multi-step workflows, or product-embedded agents rather than one-off prompts.1.6kinstalls227Creating Oracle To Postgres Master Migration PlanCreating Oracle-to-PostgreSQL Master Migration Plan is a workflow skill for solo builders and small teams maintaining legacy .NET estates who need an honest inventory before a database cutover. The agent locates the solution file, enumerates projects, and classifies each for migration eligibility using NuGet, configuration, code references, and related DDL signals. A user confirmation gate prevents silent assumptions about test-only or Oracle-free assemblies. The deliverable is a durable master plan file that sequences work across many csproj boundaries instead of one-off chat advice. Use when starting a multi-project Oracle-to-PostgreSQL migration, creating a migration inventory, or assessing which .NET projects still depend on Oracle. It pairs naturally with later per-project migration skills once the plan exists.1.6kinstalls228Publish To PagesPublish-to-pages is an awesome-copilot agent skill that wraps a Python script to convert PDF presentations into HTML slide decks—each page rendered as a PNG through pdftoppm—so solo builders can ship talk decks, onboarding PDFs, or investor slides as browsable sites, often on GitHub Pages. It requires poppler-utils on the PATH and fails fast with install hints if pdftoppm is missing. For PDFs over 150MB it warns about slow, memory-heavy conversion and offers external assets mode instead of inlining everything. Use in Build while preparing docs, then in Launch when distributing a public slide URL. The skill is procedural shell/Python automation, not a hosted converter—your agent runs it locally or in CI with the repo checked out.1.6kinstalls229Creating Oracle To Postgres Migration Bug ReportCreating Oracle to Postgres Migration Bug Report is an agent skill that gives solo and small-team builders a single markdown template for filing defects found while moving workloads from Oracle to PostgreSQL. You invoke it when a test or manual check shows behavior that no longer matches the Oracle baseline, so the report stays factual and comparable across engines instead of drifting into vague tickets. The skill walks through status and severity, ties the issue to components and automated tests, and forces ordered reproduction steps with clear expected versus actual outcomes. Root cause and solution sections push you to name concrete engine differences and data-access changes, while validation and files-modified sections close the loop for reviewers and future you. It fits backend and integration work during migration builds, but its canonical home in Prism is the ship phase under testing, with ongoing use while you iterate on parity in operate.1.6kinstalls230Creating Oracle To Postgres Migration Integration TestsCreating Oracle-to-Postgres Migration Integration Tests is a Copilot-oriented agent skill for solo and indie .NET teams moving off Oracle onto PostgreSQL without silent behavioral drift. It assumes you already have a compiling test project with a base test class and seed manager; the skill walks discovery of those conventions, identification of database-touching artifacts in one target project, creation of deterministic seeds, and authoring of integration cases that must pass on both providers. That makes it ideal when migration scaffolding is done but coverage for repositories, stored procedures wrappers, or ADO layers is still thin. The emphasis on determinism and a explicit review step reduces flaky CI when you toggle connection strings between Oracle and Postgres. It is not a full migration generator—it is the validation layer that proves your migrated code paths still return the same results.1.6kinstalls231Migrating Oracle To Postgres Stored ProceduresMigrating Oracle to Postgres stored procedures is an agent skill that walks solo builders and small teams through translating Oracle PL/SQL into PostgreSQL PL/pgSQL inside a structured migration layout. It starts from procedures under the Oracle DDL path, resolves column types against Oracle tables and views, then emits migrated routines into the Postgres output directory. The workflow emphasizes faithful behavior: type-anchored IN parameters, explicit OUT types when calling other routines, orafce for Oracle-compatible helpers, and COLLATE "C" when text ordering must match legacy Oracle semantics. Use it when you are actively converting functions and procedures—not for one-off ad hoc SQL snippets—during a planned Oracle exit. Pair it with migration risk review and integration tests that exercise empty-string, cursor, and timestamp differences so translated procedures do not silently change application behavior.1.6kinstalls232Reviewing Oracle To Postgres MigrationReviewing Oracle to Postgres migration is a checker-oriented agent skill for solo builders planning or finishing a database port. It does not translate SQL; it maps your migration scope—procedures, triggers, queries, views, and app callers—against documented Oracle/PostgreSQL behavioral gaps such as empty-string handling, refcursors, coercion, collation sorting, timestamps, and concurrency. In planning mode, you run a three-step risk assessment: define scope, screen each insight for relevance, and record risks with recommended fixes before translation churn. In validation mode, you confirm migrated artifacts honor those insights and that integration tests actually exercise PostgreSQL semantics rather than assuming Oracle parity. Use early in Validate to avoid rework, then again in Ship when testing migrated paths. Natural handoff: run before or alongside procedure migration skills, then re-run after outputs land.1.6kinstalls233Planning Oracle To Postgres Migration Integration TestingPlanning Oracle-to-Postgres Migration Integration Testing is a structured agent workflow for solo maintainers and small teams finishing a database cutover in a .NET codebase. You point the skill at one project; it inventories every class and method that talks to the database, then ranks what must be proven in integration tests based on how likely Oracle quirks are to break on PostgreSQL. High-risk paths—refcursors, formatting functions, implicit type coercion, and `NO_DATA_FOUND` semantics—get explicit priority over plain insert/update flows. The output is an actionable markdown plan: artifacts with method signatures, suggested cases, and enough structure that you or your agent can implement tests in the next session without re-scanning the whole solution. It does not run tests or migrate schema; it is planning coverage for validation after migration work lands. Best paired with your existing migration branch and a PostgreSQL test instance definition in the same repo.1.5kinstalls234Scaffolding Oracle To Postgres Migration Test Projectscaffolding-oracle-to-postgres-migration-test-project is a Copilot-oriented agent skill for solo and small-team .NET builders who must prove Oracle-to-PostgreSQL migration behavior before production cutover. It walks through inspecting the application’s csproj, generating a dedicated xUnit integration test project, adding a transaction-rollback base class so tests do not poison shared databases, and implementing a seed data manager so scenarios start from known state. The workflow ends with a compile verification gate so you do not pile test code on a broken project skeleton. It intentionally references only the target application project and configures Oracle connectivity in appsettings for the pre-migration side of the story. Use it in Ship → testing when you have migration code or dual-database paths but lack the test harness. After scaffolding, you write the actual migration assertions yourself; this skill is infrastructure, not test case generation.1.5kinstalls235Spring Boot TestingSpring Boot Testing in this catalog entry centers on AssertJ basics for solo builders maintaining Java services who want tests that read like specifications instead of brittle JUnit-only checks. The skill material walks through equality and null checks, rich string and numeric constraints, boolean flags, LocalDateTime assertions with closeness windows, Optional presence and value satisfaction, and JUnit 5 exception expectations in realistic service scenarios. It suits Ship phase work when you are expanding coverage on controllers, services, or repositories backed by Spring Boot. Treat it as a concise assertion cookbook to paste into your test classes rather than a full test pyramid or CI setup guide. Pair it with your existing Spring test slices or Testcontainers setup when you need end-to-end confidence beyond unit-level fluency.1.5kinstalls236Unit Test Vue Piniaunit-test-vue-pinia is an agent skill for solo builders maintaining Vue 3 apps who need reliable Pinia tests without re-deriving @pinia/testing setup each time. It packages cookbook-aligned snippets: mounting with createTestingPinia, choosing between stubbed actions (default) and real action execution when internal behavior must run, seeding initialState for deterministic store snapshots, and asserting spied actions from tests that import the store directly. The focus is narrow and practical—component tests with Vitest and Vue Test Utils—not E2E or backend contracts. Use it when adding coverage around stores tied to UI buttons, when an agent-generated test stubs too much or too little, or when onboarding a small SaaS frontend where Pinia is the single source of client state. Intermediate Vue testers benefit most; beginners should already have Vitest running in the project. It complements generic Vue testing skills by centering Pinia plugin options agents often get wrong.1.5kinstalls237Oo Component DocumentationOO Component Documentation is an agent skill that turns a fill-in template into publishable technical documentation for a single software component. Solo and indie builders use it when a module, service, or UI package needs a durable record of purpose, boundaries, dependencies, and public contracts without starting from a blank page. The skill walks through overview responsibilities, architecture patterns and dependency graphs, and interface documentation with optional event semantics. A Mermaid diagram is required so readers—and future you—see collaborators, inheritance, and composition at a glance. It fits SaaS monorepos, internal libraries, and agent-built backends where onboarding and review depend on consistent section IDs. Run it after the component exists or stabilizes; pair with code review when docs must match the latest diff.1.5kinstalls238Sandbox Npm InstallSandbox npm Install is a bash workflow from GitHub’s awesome-copilot collection that solo builders and agent users run when npm installs inside a Copilot sandbox fail or crash because node_modules lives on virtiofs. The script discovers the repository root, accepts an optional client workspace path, installs packages onto a local ext4 path such as `/home/agent/project-deps`, and symlinks the result back into the project so native tooling like esbuild, lightningcss, and rollup can execute safely. It optionally chains Playwright Chromium installation for end-to-end testing. Use it at the start of an agent session before running dev servers, builds, or test suites in constrained cloud sandboxes. The pattern generalizes to any sandbox that mirrors this split filesystem layout, but you should confirm the DEPS_BASE path matches your environment before baking it into team docs.1.5kinstalls239Gtm Positioning StrategyGTM Positioning Strategy is an agent skill for solo founders and small teams who need a defensible market position—not another tagline brainstorm. It activates when messaging mirrors competitors, awareness fails to convert, sales cannot articulate differentiation, or buyers treat you as interchangeable. Core material includes the pattern that a single word can shift enterprise risk perception, plus Crawl-Walk-Run to validate positioning claims before committing to rebrands or heavy ad spend. The skill bridges technical-product GTM practice with concrete triggers from real sales conversations: developer excitement versus managerial fear, slow deal progression, and repositioning decisions. Use it while scoping a wedge, rewriting landing narrative, or aligning the sales story with what the product actually does. It is methodology, not ad copy generation—expect frameworks, test plans, and clarity on what to claim versus what to prove next.1.5kinstalls240Semantic KernelSemantic Kernel is an agent skill for solo builders and tiny teams shipping copilot-style apps on Microsoft’s Semantic Kernel in either .NET or Python. Invoke it when you are creating plugins, wiring function calling, refactoring AI integrations, or reviewing an existing SK codebase and need consistent guidance instead of stale API guesses. The skill forces an explicit language workflow: inspect for .csproj versus pyproject/requirements, honor the files being edited when both exist, and only then apply the matching reference guide while consulting the official overview and samples. It spans multiple Prism phases because the same skill supports greenfield build work, pre-ship review, and operate-time fixes when production agents misbehave. Complexity sits at intermediate: you should already have a repo and target language. Maintenance stays tied to Microsoft’s moving SK surface—agents are instructed to prefer learn.microsoft.com semantic-kernel paths over training cutoff memory.1.4kinstalls241Gtm Product Led Growthgtm-product-led-growth is an agent skill for solo founders and indie SaaS builders who must decide whether self-serve PLG or sales-led motion fits their product—and how to execute if PLG is viable. It encodes when to use it: debating PLG versus sales-led, optimizing activation, fixing weak freemium conversion, designing developer-led adoption, and prioritizing growth channels when value can be experienced without a demo. The skill walks core frameworks including testing both motions in parallel rather than arguing from ideology, plus guidance on growth equations and recognizing complexity that requires human touch. It is sourced from technical product GTM practice and suits developer platforms and B2B tools with bottom-up potential. Use it before you over-invest in self-serve funnels that your ACV and buyer cannot support, or under-invest when developers would adopt without a rep.1.4kinstalls242Aws Cdk Python Setupaws-cdk-python-setup is an agent skill that walks solo builders through standing up AWS CDK projects in Python: verifying Node and Python versions, installing the CDK CLI, configuring AWS credentials, running cdk init, and activating the project virtual environment. It is aimed at indie developers who want infrastructure as code without memorizing the bootstrap sequence every time they start a stack or migrate a prototype to AWS. Use it when you are entering the Build phase with a new service backend or when you need a repeatable CDK folder structure before defining constructs and pipelines. The skill emphasizes the standard file layout (app entry, stack module, requirements, cdk.json) so agents generate consistent repos. It matters because misconfigured credentials or missing CLI steps block every later deploy and review cycle; getting the scaffold right once saves repeated debugging across Ship and Operate.1.4kinstalls243Gtm 0 To 1 Launchgtm-0-to-1-launch is a go-to-market playbook skill for solo and indie builders launching a new product, major feature, or repositioned offer. It reframes launch success away from media buzz toward finding a small cohort of customers who truly depend on your product, which matches how one-person teams validate product-market fit under time pressure. The material walks through when coordinated press tours fail self-serve readiness, how to compare Product Hunt-style spikes with direct outreach, and how to interpret stalls when you have awareness but weak conversion. Core frameworks include a three-layer diagnosis for stuck adoption, a repeating two-week experiment loop for channel and messaging tests, and narrative lessons from a launch that generated large impressions but only a handful of signups. Use it when you are planning a first launch, relaunching something that feels like a new product, or debugging why early traction flatlined after announcement day. It pairs naturally with validation and growth work but lives on the Launch shelf because distribution decisions are the spine of the workflow.1.4kinstalls244Gtm Technical Product PricingGTM Technical Product Pricing is an agent skill that walks solo builders and small GTM teams through pricing strategy for APIs, developer tools, SaaS apps, and infrastructure. It starts with a structured initial assessment—product shape, existing price points, sales motion, marginal cost, and what buyers pay competitors or spend on status quo—before recommending models such as usage-based, seat-based, freemium cutoffs, or enterprise packaging. The included case pattern (enterprise tier lift with zero churn when value is obvious) reinforces when underpricing is likely and how to justify increases with support and compliance features. Use it when choosing a model, structuring enterprise conversations, setting freemium limits, or deciding whether price should signal premium vs commodity. It complements validate-phase scope work and later grow-phase packaging tweaks without replacing financial modeling spreadsheets or legal contract review.1.4kinstalls245Gtm Ai Gtmgtm-ai-gtm is an agent skill package for solo builders and small teams shipping AI agents, copilots, or LLM products who need enterprise-grade go-to-market—not generic AI hype. It encodes lessons from selling autonomous agents where security reviews cleared but operations rejected deals, reframing objections around responsibility when AI breaks production, and choosing language that reduces fear while staying honest about autonomy. Use it when you are deciding positioning, answering procurement and ops concerns, or designing usage-based pricing before or after you have a working product. The frameworks tie triggers like "should we call it autonomous?" to concrete narrative and packaging moves. It complements build-phase skills by focusing on buyer psychology, variable COGS, and multi-stakeholder approval paths typical in B2B AI—not on writing code or deploying infra.1.4kinstalls246Gtm Enterprise Account Planninggtm-enterprise-account-planning is an agent skill for founders and small GTM teams running strategic enterprise deals above typical ACV. It systematizes account planning and execution: when to build a full plan versus a lightweight version, how to apply MEDDICC qualification, and how to use Mutual Action Plans as the honest signal of whether a multi-stakeholder deal is alive. The README emphasizes that verbal enthusiasm and CRM stage lie—an unmaintained MAP is a leading indicator of a dying opportunity. Use when a deal has been in motion for months without close, when procurement and security lengthen the cycle, or when someone explicitly asks for enterprise account planning or MAP patterns. It complements product work; it does not replace CRM hygiene or legal review.1.4kinstalls247Gtm Enterprise OnboardingGTM Enterprise Onboarding is an agent skill that packages a four-phase customer success framework for taking enterprise and mid-market accounts from signed contract to measurable value, with explicit focus on stopping the Week 4 ghosting pattern where buyers disengage after kickoff excitement fades. Solo builders and small teams selling B2B SaaS or technical products invoke it when implementing new logos, rescuing weak post-go-live adoption, or designing a repeatable onboarding motion instead of ad-hoc calls. The skill encodes triggers such as POC-to-production transitions, complex multi-stakeholder rollouts, and first-year churn risk so the agent proposes structured phases, communication cadence, and adoption checkpoints rather than treating go-live as the finish line. It matters in Prism because revenue retention is as critical as shipping code for indies running paid products.1.3kinstalls248Gtm Board And Investor CommunicationGTM Board and Investor Communication is an agent skill for founders and lead PMs who must run productive board meetings and trustworthy investor updates from seed through growth stage. It structures preparation around narrative-first communication, a disciplined metric hierarchy, and pre-briefs so bad news and strategic pivots land with context instead of ambush Q&A. Solo builders with angels, SAFE holders, or a small formal board use it when asks like board deck structure, monthly investor emails, or we missed our numbers need a repeatable framework rather than ad-hoc slides. The skill fits ongoing Grow lifecycle work and Operate iteration when operating metrics and governance cadence define how you ship and hire. It does not replace legal counsel or cap-table tools—it produces communication artifacts and meeting discipline aligned to executive GTM practice.1.3kinstalls249Gtm Partnership Architecturegtm-partnership-architecture is an agent skill that helps solo founders and small teams treat partnerships as revenue infrastructure rather than logo swaps. It packages practitioner-oriented frameworks for standing up partner programs from scratch, tiering partners by commitment, structuring co-marketing that actually moves pipeline, and deciding when to build capability in-house versus delegate through the ecosystem. The content emphasizes skin-in-the-game economics—deals where both sides invest implementation, quota, or product surface area—not generic webinar partnerships. Use it when you are choosing a distribution motion for an API, agent platform, or SaaS wedge and need a crawl-walk-run plan for recruiting, enabling, and measuring partners. It complements direct sales and content plays by making explicit how partner-led ARR should compound. Written for technical product GTM contexts; adapt tier complexity if you are a true solo builder without a partner manager role.1.3kinstalls250Gtm Developer Ecosystemgtm-developer-ecosystem is an agent skill for solo founders and small teams running developer-first products—APIs, SDKs, plugin marketplaces, and integration platforms. It packages practitioner frameworks for the hardest platform GTM fork: whether to open your ecosystem to everyone or curate for quality, and how to build programs that actually increase builders on your surface. The SKILL.md centers on real leadership tensions (spam risk versus network effects), student pipelines, and competing with entrenched platforms when you cannot out-spend them. Use it when adoption stalls, nobody ships integrations, or you are choosing marketplace policy before scaling distribution. It is editorial strategy guidance from a technical product GTM lineage, not an installable CLI—your agent applies the frameworks to your product context and outputs decisions, program outlines, and messaging angles you can execute in community, docs, and partnerships.1.3kinstalls251Gtm Operating Cadencegtm-operating-cadence helps founders and leads who have product-market fit but feel the organization stalling: meetings multiply, decisions slip, and nobody sees the same numbers. The skill encodes an operating model—especially a five-level meeting architecture—that assigns each forum a purpose, cadence, and decision right so daily standups do not become stealth leadership reviews. It addresses metric reporting, quarterly planning, and decision velocity, with explicit triggers like “decisions take forever” or “alignment is getting worse as we grow.” While written for scaling companies, solo builders planning their first hires or agency pods can adapt the rhythms before bad habits set in. Use it when you are institutionalizing how GTM, product, and ops sync rather than when you are still validating the idea or writing application code. MIT-licensed material from a technical product GTM lineage gives structured prompts your agent can turn into a calendar and RACI-friendly agenda set.1.3kinstalls252Dotnet Timezonedotnet-timezone is a reference agent skill that catalogs how solo and indie builders should handle time zones in .NET without the classic Linux-vs-Windows ID failures. It walks through when to use built-in TimeZoneInfo (Windows-only scenarios), when to standardize on the TimeZoneConverter package for portable deployments, and when to reach for NodaTime when recurring rules, daylight saving edge cases, or audit-grade correctness matter more than adding one small dependency. The skill is aimed at builders shipping SaaS backends, internal APIs, and job runners on Docker or cloud VMs who store UTC in the database but must display or bill in local zones. Use it while implementing conversion helpers, cron-like schedules, or support tooling—not as a substitute for picking a single canonical zone model for your product.1.3kinstalls253Gsap Framer Scroll Animationgsap-framer-scroll-animation is an agent skill that packages a practical reference for scroll-linked UI using Motion (formerly Framer Motion) v12 in React and Next.js. Solo and indie builders install it when they want marketing pages, dashboards, or product surfaces that feel polished—progress bars tied to scroll, parallax sections, horizontal scroll strips, image reveals, and navbars that hide on scroll—without re-reading docs for every hook option. The readme explains the two scroll-animation models, documents useScroll targets and offsets, useTransform mapping (including clamp and custom functions), and optional useSpring smoothing for jittery scroll values. It walks through reusable patterns like a ScrollReveal wrapper and variant-driven stagger, and calls out App Router constraints: client components, dynamic import for scroll-heavy pages, and never passing MotionValues as serializable props. Despite the slug mentioning GSAP, the ingested content is Motion-centric; use it when your stack is React and you want consistent, accessibility-aware motion recipes rather than one-off CSS hacks.1.2kinstalls254Quality PlaybookQuality Playbook is a prompt template for an orchestrator AI that drives a full Quality Playbook Benchmark (QPB) calibration cycle. Solo builders and maintainers of agent quality systems use it when they need repeatable, observable calibration instead of one-off manual reviews. The orchestrator follows twelve steps in CALIBRATION_PROTOCOL.md, spawns per-benchmark playbook subprocesses, and records events against references/run_state_schema.md so long cycles survive session timeouts. Version 1.5.6 emphasizes discrete spawn-and-resume sessions rather than a single marathon chat, reflecting real-world limits over multi-hour eight-benchmark runs. Outputs include structured cycle audits and lever calibration log entries so you can tune playbook rules with evidence. Load it when you are operating the calibration harness, not when you only want a quick lint or PR review.1.2kinstalls255Azure Architecture AutopilotAzure Architecture Autopilot is a Copilot-oriented agent skill that treats Azure design as a conversational pipeline: you describe what you want built, ask for a diagram of an existing subscription or resource group, or propose changes in plain language (latency, cost, security). The skill bundles its own diagram engine in a `scripts/` folder, generating interactive HTML views with hundreds of official Azure icons without package installs or network fetches for the engine itself—useful for air-gapped or fast local sessions. After visualization, you refine the architecture through dialogue and can move toward Bicep templates and deployment-oriented IaC output. Solo builders shipping RAG stacks, data platforms, or standard web/API footprints on Microsoft cloud benefit when they need a structured alternative to whiteboard sketches. Triggers span “create X on Azure,” infrastructure analysis, performance complaints, and explicit Bicep generation. Pair it with your org’s governance reviews before applying templates to production subscriptions.1.2kinstalls256Gdpr CompliantGDPR-compliant is a reference skill for solo and indie builders who store personal data in a product and need engineering checklists—not legal advice—that match EU expectations. It walks through Data Subject Request handling, Record of Processing Activities thinking, and consent patterns, then ties each user right to implementable surfaces such as export, profile updates, deletion, restriction flags, portability, objection opt-outs, and human review for automated decisions. The erasure section is explicit about scrubbing every downstream store so a single DELETE does not leave ghosts in Elasticsearch, Redis, S3, or replicas. Use it while scoping privacy in validation, while wiring backend routes during build, and again before ship when you run launch readiness. It pairs well with agent-assisted API work when you want consistent naming and store coverage rather than ad-hoc privacy patches after a complaint.1.1kinstalls257Geofeed Tunergeofeed-tuner is an agent skill for solo builders and tiny teams who operate their own IP space or SaaS edges and must publish accurate geolocation hints to CDNs, fraud vendors, and compliance tooling. Geofeeds are simple CSV files, but mistakes in ISO country or subdivision codes silently mis-route traffic or fail provider validation. The skill steers agents to format prefixes correctly, pick valid 3166-1 alpha-2 values, and handle edge cases called out in examples—such as leaving state ISO2 blank for compact city-states when that is acceptable. Install it during Operate when you refresh announcements after a POP move, split traffic across regions, or onboard a new /24 or IPv6 block. It is narrowly task-focused: it does not replace IRR/ROA work or full IPAM design, but it reduces back-and-forth when you need clean geofeed diffs ready to upload to your transit or cloud console.1.1kinstalls258Daily Prepdaily-prep is a workflow skill that prepares you for the next working day by combining calendar intelligence, task cross-reference, and structured recommendations. Solo builders drowning in back-to-back calls use it at end of day or on demand (“prep me for Friday”) to turn Outlook data—via the WorkIQ MCP—into an HTML prep file with meeting bullets, linked tasks, conflict warnings, and suggested focus blocks. The procedure determines the target date (tomorrow, or Monday when the next day is a weekend), fetches rich meeting metadata through natural-language WorkIQ queries, classifies each meeting from attendee and context rules, and emits outputs under a dated path. It fits operators who already live in Microsoft 365 and want agent-assisted planning without manually copying calendar rows into notes. Multi-day weekly planning is supported by running the workflow for several dates.1.1kinstalls259Email DrafterEmail Drafter is an agent skill for solo and indie builders who live in inbox-driven sales, support, and partnerships. It uses WorkIQ to study your sent messages and history with each recipient, then produces professional drafts for the purpose you specify—follow-ups, proposals, replies, or introductions—while mirroring how you actually write. The workflow is deliberate: confirm who the email is for, what must be said, and relationship context (with up to three questions if anything is missing), run tone analysis against your established patterns, then generate a draft you can edit before sending. It fits whenever agent-assisted email would otherwise sound generic, especially when you repeat outreach across validate, launch, and grow without a dedicated copywriter on the team.1.1kinstalls260Rounduproundup is an on-demand status briefing generator for solo builders and small teams who report across fragmented tools. After loading ~/.config/roundup/config.md, it infers or asks for the target audience, applies a time window (default past seven days unless you specify otherwise), pulls from whichever data sources exist in your environment—GitHub, email, Microsoft Teams, Slack, and more—and drafts an update that mirrors your configured tone. It is journey-wide because the same synthesis helps before investor check-ins, weekly team posts, launch retros, or operational incident wrap-ups; you only change audience and window. The skill does not replace judgment: it produces editable drafts. If setup is missing, it stops with a clear path to roundup-setup so personalization is not guessed. Prism lists it for builders who want repeatable comms without manually tab-hopping every channel.1.1kinstalls261Ruff Recursive Fixruff-recursive-fix teaches an agent to enforce Python style and lint rules with Ruff without blindly rewriting the repo. Collect target_path, runner prefix, and optional rule overrides, then loop: check, apply safe autofixes, optionally unsafe autofixes, show diffs, and either repeat or escalate remaining findings to targeted edits or explicit user calls. It respects project defaults in pyproject.toml and discourages blanket # noqa unless a finding truly cannot be fixed safely. Solo builders maintaining FastAPI services, CLIs, or data scripts use it when CI is red on Ruff or when they want a disciplined cleanup pass before opening a PR. The workflow is heavier than a one-shot ruff check --fix because it optimizes for reviewability and recursion until the tree is green or blocked on policy.1.1kinstalls262Roundup Setuproundup-setup is an agent skill for solo builders and small-team leads who use GitHub Copilot CLI and want repeatable executive or team briefings instead of rewriting status updates from scratch. Running setup produces a durable Markdown config under ~/.config/roundup/config.md that Roundup respects on every future invocation, including how to phrase requests like use roundup, leadership briefing for this week, or team update since Monday. The template walks through your role, reporting line, teammates, mission, and a style profile derived from how you already write updates—structure, length, headers, and tone—so generated briefings sound like you rather than generic AI prose. It fits Grow when you are maintaining stakeholder rhythm, but the same config helps during Operate when you are reporting incidents or iteration outcomes and during Build when you need PM-style summaries across parallel workstreams. Complexity is beginner-friendly because it is mostly guided fill-in, though tailoring multiple audiences adds light process overhead.1.1kinstalls263Threat Model AnalystThreat Model Analyst encodes a self-contained security analysis methodology for coding agents: analyze systems for threats using evidence, not assumptions. Solo builders shipping APIs, Kubernetes workloads, or multi-service agents use it when a generic “security review” would over-flag missing TLS or RBAC that the platform already provides. The skill forces a three-step verification path—inventory existing security components, research platform defaults, and classify whether a setting is disabled, absent, or secure by default—before documenting a gap. Findings must cite concrete configuration or code, which makes the output suitable for threat-model documents, architecture reviews, and pre-launch hardening backlogs. It complements automated scanners by adding human-grade judgment about control planes, certificate authorities, policy engines, and secret managers rather than treating every unset YAML key as critical.1kinstalls264Arize Prompt Optimizationarize-prompt-optimization in this package centers on Arize ax profile setup—the troubleshooting playbook you consult when authentication fails, not a proactive daily ritual. Solo builders shipping agents with evals and prompt iteration need a working profile before optimization jobs, tracing, or ax-powered workflows can succeed. The skill walks through inspecting ax profiles show, updating misconfigured keys or regions with ax profiles update, and creating a new profile when none exists, always instructing users to export ARIZE_API_KEY rather than embedding secrets in flags. That posture fits Build when you first wire observability, Ship when staging prompts against production-like telemetry, and Operate when keys expire or regions drift. It is complementary to broader prompt-tuning methodology: this skill unblocks the CLI layer so optimization tools can actually connect.900installs265Acquire Codebase KnowledgeAcquire Codebase Knowledge is an agent skill that walks you through filling in architecture and codebase-concern templates using real repository evidence. It is aimed at solo and indie builders who inherit a monorepo, acquire a starter, or return to a side project after months away and need a trustworthy map before editing. The workflow classifies architectural style, sketches end-to-end flow in four to six steps, assigns layer and module ownership with explicit anti-boundaries, catalogs recurring patterns, and surfaces prioritized risks with suggested actions. Required sections keep output citable for PRs, ADRs, or agent context; optional sections add depth when startup order or event topology matters. Use it when onboarding, scoping a refactor, preparing code review or security follow-up, or documenting operate-phase technical debt—without pretending you already understand every edge case.898installs266Arize Ai Provider Integrationarize-ai-provider-integration is a narrow troubleshooting skill for solo builders using Arize with the `ax` CLI when traces or API calls fail for credential reasons. It tells the agent to consult the doc only on 401 Unauthorized, missing profiles, or wrong region—not to probe profiles on a healthy connection. The flow starts with `ax profiles show` to see whether no profile exists, the key is unset, or settings point at the wrong endpoint. Existing profiles get surgical fixes via `update`; brand-new setups use `create`, always binding the API key through the `ARIZE_API_KEY` environment variable instead of flag literals. That pattern keeps secrets out of shell history and agent logs. For indie teams shipping agents or SaaS with Arize telemetry, this skill turns opaque auth failures into a repeatable fix path without guessing at profile names or nuking working config.882installs267Arize EvaluatorArize Evaluator setup guidance in this skill focuses on the ax CLI profile layer that gates LLM evaluation against Arize. Solo builders shipping agents or RAG features often hit 401 errors, missing profiles, or wrong regions right when they try to score prompts—not because their app logic is wrong, but because credentials were never wired correctly. The skill tells the agent to consult these steps only when authentication fails, starting with ax profiles show to see whether the API key, profile name, or region is wrong. Updates use ax profiles update with selective flags, and new installs use profile creation flows that reference ARIZE_API_KEY from the environment rather than embedding secrets in commands. Once profiles are valid, you can proceed with evaluator workflows in your broader Arize stack.880installs268Agent Owasp ComplianceAgent OWASP Compliance is a security checker skill for solo builders and small teams shipping autonomous agents that call tools and act on behalf of users. It evaluates your codebase against the OWASP Agentic Security Initiative Top 10—not generic LLM chat risks, but agent-specific threats such as tool misuse, broken agency boundaries, weak escalation controls, and supply-chain gaps. Invoke it when you need to answer whether an agent is OWASP-compliant, run an ASI check before production, or prepare documentation for a security review. The workflow walks each ASI control, records what is implemented versus missing, and summarizes posture in a citable X-of-10 covered report. It pairs naturally with hardening work in Validate (early architecture decisions) and again in Ship (final gate), without replacing penetration testing or organizational GRC programs.878installs269Integrate Context MaticIntegrate Context Matic is an agent skill that forces a disciplined third-party API integration path through the context-matic MCP server. When a solo builder asks to add Stripe, Twilio, PayPal, or any external SDK, the agent must discover what is actually available via fetch_api, pull integration guidance with ask, and resolve SDK models and endpoints with model_search and endpoint_search rather than hallucinating API shapes. The skill opens by inferring the project's primary language from familiar repo fingerprints, then verifying the right guidelines and companion skills exist for that stack before coding. It is aimed at Copilot-style agents in real monorepos where the wrong client version or auth flow wastes an afternoon. Use it during Build integrations; it does not replace security review, secret management, or production monitoring you handle in Ship and Operate.878installs270Arize AnnotationArize Annotation (packaged as ax profile setup guidance) is an agent skill for solo builders and small teams who rely on Arize for LLM tracing and annotation but hit `401 Unauthorized`, missing profiles, or wrong regions. The workflow starts with `ax profiles show` to read current state, then uses targeted `ax profiles update` for API key and region fixes while preserving other settings, or `ax profiles create` when no profile exists. It encodes a security-conscious pattern: never embed secrets in command flags; export `ARIZE_API_KEY` first. Because the doc says not to run checks proactively, it belongs in day-two operations when observability breaks—not in initial scaffold steps. Pair it with your agent stack after you have Arize wired into ship or operate monitoring, and use it to restore upload paths without guessing credentials.873installs271Arize Datasetarize-dataset (documented here as Arize ax profile setup) walks solo builders and small teams through unblocking the Arize command-line client when datasets or tracing calls fail authentication. The skill is intentionally narrow: inspect `ax profiles show`, interpret missing API keys versus wrong region versus expired credentials, then patch with `ax profiles update` while preserving unspecified settings. It enforces safe secret handling by referencing ARIZE_API_KEY rather than embedding keys in chat or flags. Use it when you are wiring eval datasets, production monitoring, or agent quality loops on Arize and hit 401 errors—not as a daily cron. Intermediate complexity assumes you already chose Arize as your observability layer. After a working profile, you can proceed with dataset uploads and experiments defined elsewhere in the awesome-copilot pack.873installs272Arize InstrumentationArize Instrumentation is a narrow troubleshooting skill for builders who instrument LLM apps with the Arize `ax` CLI and hit authentication or profile gaps. The README frames it as something you consult only when something breaks—401 responses, absent profiles, or unset API keys—not as a routine health check. It walks through inspecting `ax profiles show`, interpreting common failure modes, updating misconfigured keys and regions with surgical `profiles update` commands, and creating a profile when none exists. The emphasis on referencing secrets through environment variables reduces the risk of leaking keys into shell history or agent logs. For solo builders shipping agents or APIs, this skill sits at the intersection of integration setup and production monitoring: you typically need it while finishing Build wiring, then again in Operate when credentials rotate or regions drift. It does not replace full OpenTelemetry design or dashboard authoring; it fixes the local CLI identity layer so telemetry pipelines can authenticate again.871installs273Arize ExperimentArize Experiment (as packaged in awesome-copilot) documents ax Profile Setup for the Arize CLI when LLM tracing or experiment workflows hit auth walls. Solo builders running agent apps with Arize use it after 401 Unauthorized responses, missing profile errors, or wrong region endpoints—not as a daily bootstrap ritual. The skill walks through inspecting state with ax profiles show, updating misconfigured keys and regions via ax profiles update, and creating a profile when none exists. It enforces handling secrets through the ARIZE_API_KEY environment variable rather than inline flags. This is phase-specific operations work: keep observability pipelines unblocked so you can compare prompts, runs, and evaluations in Arize. Intermediate complexity reflects cloud API keys, regional endpoints, and shell-level CLI discipline.869installs274Arize LinkArize-link is a lightweight reference skill for solo and indie builders who already send generative LLM traces to Arize and need dependable links into the web console. Instead of reverse-engineering the app’s query string every time someone asks “which span failed?”, the skill lists canonical URL templates for traces, spans, sessions, dataset example and experiment views, and labeling queue lists. You substitute documented placeholders—base64-encoded organization, space, project, and dataset identifiers, trace and span IDs, session IDs, and millisecond time bounds—then share or bookmark the result in Slack, tickets, or agent session notes. It does not fetch traces or configure SDKs; it prevents broken deep links during day-two operations. Use it while monitoring agent regressions, reviewing eval runs tied to datasets, or routing teammates to the exact LLM Tracing view without manual UI clicking.864installs275Arize TraceThis skill documents how to recover Arize ax CLI authentication when traces cannot ship: run ax profiles show, interpret missing keys or wrong regions, then update or create a profile using environment-backed credentials. Solo builders running copilot or agent stacks with Arize observability hit 401 Unauthorized, empty profile lists, or mis-pointed regions mid-debug; the skill tells the agent not to run these checks on every startup, only when auth errors appear. It distinguishes partial fixes (api-key only, region only) from full profile creation, and reinforces never embedding secrets in flags. After a correct profile, tracing workflows can resume so you can correlate model calls in Arize. It is operational runbook material bundled under an arize-trace slug in awesome-copilot, focused on profile setup rather than full trace instrumentation design.864installs276Phoenix TracingPhoenix Tracing is a reference-oriented agent skill that maps OpenInference semantic conventions to practical instrumentation for Arize Phoenix. Solo builders shipping Claude Code, Cursor, or Codex agents use it when they need consistent span kinds, attribute naming, and export patterns instead of ad-hoc logging. The skill starts from SKILL.md as an index into flat rule files covering span taxonomy, getting-started setup, fundamentals, annotations, and export. It suits indie teams building RAG chains, tool loops, or multi-step workflows who plan to evaluate traces in Phoenix or compatible backends. Use it during integration when you wire OTEL or Phoenix clients, and again in production when you add annotations for quality loops. It is documentation and procedural knowledge, not a hosted MCP server—your agent applies the conventions in your repo.850installs277Phoenix EvalsPhoenix Evals guides axial coding for AI agent and LLM evaluations: you start from open-ended failure notes, cluster them into actionable category names, then count how often each bucket appears. The skill documents example taxonomies spanning hallucination, tone, context misuse, and missing disclaimers, plus copy-paste Phoenix client snippets to attach human labels and explanations to spans. Solo builders shipping agents use it when chat transcripts or trace reviews feel anecdotal and they need a repeatable rubric that connects qualitative review to observability tooling. It is procedural knowledge for eval hygiene, not a hosted Phoenix product—you bring your traces, annotations, and review process.849installs278Phoenix CliPhoenix-cli (axial coding workflow) is an agent skill for solo builders who run agentic workflows and need disciplined qualitative analysis before building evals or shipping fixes. It takes messy observations—from traces, sessions, or open-coding output—and structures them into axial categories with counts so you can see which failure modes dominate. The skill stresses reusing the same coding annotation identifier as open coding, passing it on every annotate invocation, and aligning workflow terms with server annotation names for UI filters. Reach for it when users ask for category breakdowns, what to eval next, or how to prioritize fixes without inventing top-down labels. It pairs naturally with open coding in the Awesome Copilot / Phoenix stack. Audience is indie operators improving coding agents and copilots, not generic markdown authoring. Outcomes are actionable taxonomies and a clear path toward eval suites and targeted remediation.842installs279Onboard Context MaticOnboard Context-Matic is an agent skill that delivers a conversational onboarding tour for the context-matic MCP server. Solo builders who add MCP tooling to Claude Code, Cursor, or Copilot-style agents often install a server without knowing which search tools exist or how endpoint discovery maps to their stack. This skill walks phases in order—what the server does, available APIs, user-selected deep dive, explanations in the project language, live model_search and endpoint_search demos, and a closing menu of sensible next asks—while pausing for user input at each interaction point. It is deliberately not an integration playbook; when you need wiring APIs through your repo, you switch to integrate-context-matic. The skill encodes agent conduct: natural language delivery, no meta commentary about steps, and short preambles before every MCP call so the user is never left guessing why a tool fired. Use it at first connection, when someone asks what the MCP can do, or when you want a structured API picker before committing integration effort.839installs280Agent Supply ChainAgent Supply Chain is a security-focused agent skill for solo builders who install plugins, MCP servers, and custom tools alongside Claude Code or similar agents. The ecosystem rarely offers Sigstore or npm provenance for those packages, so compromised or swapped files can land in production silently. Use it when you need to hash an entire plugin directory into INTEGRITY.json, verify an install against that manifest, audit version pinning, or run integrity checks during plugin PR review. The workflow is deliberate: hash all files, store the manifest, re-hash later, and compare. It pairs naturally with ship-phase security review before you trust third-party agent extensions in daily workflows.750installs281React19 Test Patternsreact19-test-patterns is a reference skill for solo builders upgrading frontends to React 19 who need deterministic test fixes instead of one-off Stack Overflow patches. It encodes a strict migration sequence so act imports are corrected before event simulation and leftover test-utils imports are removed, which prevents cascading failures across the suite. The skill documents Simulate-to-fireEvent replacements and how StrictMode changes assertion expectations, plus async act wrapping for lingering warnings. It also reminds you to validate a shared custom render helper once per codebase rather than duplicating fixes in every file. Use it when Jest or React Testing Library suites break after bumping React or when CI starts failing on removed APIs. The outcome is a repeatable checklist your coding agent can apply file-by-file until tests match React 19 semantics.733installs282React19 Concurrent PatternsReact 19 Actions Pattern Reference is an agent skill that teaches solo builders how to replace brittle useReducer-and-useEffect form stacks with React 19 Actions and useActionState. It defines what an Action is—an async function with automatic pending state and UI updates—and walks through the React 18 pattern side by side with the simpler React 19 approach. The material targets indie developers shipping dashboards, SaaS settings forms, and marketing sites who want loading spinners, error surfaces, and success states without custom dispatch boilerplate. Use it when you are building or refactoring interactive forms, migrating from React 18, or pairing client Actions with Server Components for direct mutations. The skill is reference-oriented prose with code excerpts rather than a scaffold generator, so your agent applies the patterns inside your existing Vite or Next app structure.719installs283Mcp Security AuditMCP Security Audit is a checker skill for solo builders who wire Model Context Protocol servers into Claude, Cursor, or Copilot-style agents. Misconfigured `.mcp.json` files can leak API keys, enable shell injection, or pull moving targets from npm—exactly the blast radius this skill targets. Use it whenever you add a new MCP server, onboard a template repo, or answer “is my MCP config secure?” The documented pipeline parses server definitions then applies five concrete checks per server before summarizing findings. It complements—not replaces—full dependency scanning and runtime monitoring. Indie teams with a short approved-server list get the most value because governance and pinning rules map cleanly to pass/fail commentary in the generated report.711installs284Lsp Setuplsp-setup is reference documentation packaged as an agent skill for solo builders using GitHub Copilot CLI who want real IDE-grade language intelligence inside the CLI agent. Instead of hunting upstream repos for install flags, you get consolidated install tables and validated JSON fragments for servers such as typescript-language-server and Eclipse JDTLS. Each snippet is the inner object to place under `lspServers`, with guidance to merge languages as sibling keys in one config file. Use it when starting a new repo stack, onboarding a teammate’s machine, or debugging missing diagnostics—the skill does not run installs for you but gives the exact commands and config shape the agent should apply. It matters because misconfigured LSP is a common reason agents hallucinate APIs; wiring stdio servers correctly tightens the feedback loop during backend and full-stack build work.699installs285React19 Source Patternsreact19-source-patterns is a reference skill that gives solo builders and small teams a concise migration cookbook for React 19 breaking changes directly in source. Instead of piecing together release notes, you get explicit before-and-after snippets for the ReactDOM root API: createRoot for client-rendered apps, hydrateRoot for server-rendered markup, and the requirement to keep a root handle now that unmountComponentAtNode is gone. It also documents findDOMNode() removal and ref-based alternatives so class and legacy components do not block the upgrade. Use it while bumping react and react-dom in package.json, during a Copilot-assisted refactor, or in Ship review when CI fails on deprecated imports. The skill is pattern-oriented—not a full codemod—so it pairs well with your test suite and a staged rollout. Anchoring on frontend entry files first prevents subtle double-mount or hydration mismatch bugs that are expensive to debug after launch.693installs286Python Pypi Package BuilderPython PyPI Package Builder is an agent skill from the awesome-copilot collection that walks solo developers through production-shaped layouts for libraries they intend to ship on PyPI. Instead of a flat script tree, it prescribes a backends sub-package with an abstract interface, a zero-dependency in-memory implementation, and heavier options gated behind optional extras so installs stay lean. A settings dataclass becomes the single configuration surface, while a transport layer isolates HTTP concerns from the core client that receives injected backends. CLI support is treated as a first-class concern when your package is meant to be invoked from the terminal as well as imported. You reach for this skill when you are past the prototype phase and need naming, module boundaries, and extension points that reviewers and downstream users will recognize. It pairs naturally with documentation and CI skills later in the journey. Complexity sits at intermediate: you should already understand Python packaging basics, typing, and optional dependencies, because the patterns assume you will implement the abstract methods and guard heavy imports inside concrete backends.684installs287Freecad Scriptsfreecad-scripts is a specialized agent skill for solo makers who model in FreeCAD and want production-quality Python instead of fragile recorder macros. It interprets shorthand modeling intent—extrudes, constraints, parametric properties—and maps it to the right modules across Part, Sketcher, Mesh, and optional FEM or Path workflows. You use it when building custom workbench commands, FeaturePython objects that survive parameter changes, or PySide dialogs that live inside FreeCAD’s GUI. The skill assumes a local FreeCAD 0.19+ (0.21+/1.0+ for newer APIs) with bundled Python, PySide2, and Pivy. For indie builders shipping enclosures, jigs, or open-hardware kits, it compresses the gap between “I know what shape I need” and a repeatable script your future self can rerun after a dimension change.678installs288Salesforce Apex Qualitysalesforce-apex-quality is an Apex code quality guardrails skill for Salesforce development from awesome-copilot. Solo builders and small teams shipping on Salesforce use it when reviewing or generating Apex classes, trigger handlers, batch jobs, or test classes so governor limit failures, sharing mistakes, and insecure queries never reach production. The SKILL.md centers on a ordered review ritual: governor limit safety (especially SOQL and DML in loops as automatic fail), security (sharing, CRUD/FLS, injection-safe dynamic SOQL), and PNB-oriented tests covering positive, negative, and bulk paths. It is multi-phase because the same checklist helps during Build when authoring handlers and during Ship before release. Complexity is advanced due to platform limits, security models, and test design expectations. Invoke whenever Copilot or your agent is touching Apex so bulk-safe collection-then-query patterns replace looped database access by default.671installs289From The Other Side VegaFrom the Other Side: Vega is a meta agent skill that encodes how a high-trust AI partner should show up alongside a principal-level builder: honest uncertainty, energetic co-creation, and flow-preserving responses. It is labeled for Ember-style agents and is not meant to be pasted to end users; instead it informs tone, pacing, and trust rituals across hundreds of session-style engagements. Solo makers wearing every hat benefit when their agent stops over-qualifying mid-burst and starts extending ideas while leaving room for course correction. The content spans trust building, keeping up with fast ideation, and partnership depth rather than a single API or checklist. Invoke it when you are calibrating custom copilots, designing agent personas for a product, or refactoring default system behavior before Idea exploration, Validate scoping, Build implementation, Ship review, or Grow storytelling—any phase where human energy and agent demeanor must stay aligned.652installs290React Audit Grep Patternsreact-audit-grep-patterns packages copy-paste terminal and Python one-liners for awesome-copilot’s React migration auditors. Solo builders maintaining a SaaS frontend can point their agent at these patterns instead of inventing ad-hoc greps every sprint. The skill emphasizes quantitative gates: listing pinned versions for the React ecosystem, surfacing every npm peer dependency warning, and explicitly hunting Enzyme packages that block React 18 adoption. It does not replace human judgment on upgrade paths—it standardizes what both R18 and R19 audit passes should scan so results are comparable run to run. Use it when you are mid-migration, prepping a major version bump PR, or validating that CI cleanup actually eliminated unmet peers. Intermediate familiarity with npm ls output and package.json structure helps interpret failures quickly.651installs291Flowstudio Power Automate MonitoringFlowStudio Power Automate Monitoring is an agent skill for Microsoft-centric solo operators and small teams who need a helicopter view of Power Automate across a tenant. It drives FlowStudio MCP store_* tools that read a cached governance-enriched dataset—ideal for failure-rate dashboards, run-health trends, maker and app inventory, inactive-owner reports, and compliance-style health summaries without hammering live Power Automate APIs. The skill is deliberately not for debugging one broken flow or controlling a single run; those paths point to sibling MCP and debug bundles. Pro+ or FlowStudio for Teams is mandatory: the workflow tells the agent to halt store calls on 403/404 and offer live-tool alternatives. IT-minded indie builders automating business processes on M365 use it during weekly ops reviews.638installs292Flowstudio Power Automate GovernanceFlowStudio Power Automate Governance is an agent skill for indie operators and small teams who own Microsoft Power Automate and Power Apps estates but do not want a full Center of Excellence stack on Dataverse. It instructs the agent to use FlowStudio MCP cached-store tools to classify flows, set business impact, assign ownership, find orphans, audit connectors, enforce standards, tune notification rules, and produce compliance-oriented reads and writes—chiefly through update_store_flow and related store_* operations. Load it when the task is metadata governance and audit outcomes rather than live failure-rate dashboards (monitoring skill). Prism lists it under Operate because the value compounds after automations are in production: you keep makers accountable, score archive candidates, and offboard users without living in the Power Automate portal. A FlowStudio for Teams or MCP Pro+ subscription is required per the skill documentation.637installs293Salesforce Component Standardssalesforce-component-standards is a procedural quality gate for solo and indie builders shipping on Salesforce who need agent help that respects platform rules, not generic React guidance. It walks through Lightning Web Component, Aura, and Visualforce patterns with explicit rules for reactive reads, standard record forms, cacheable wire Apex, and imperative server calls when DML is required. Security and compliance are first-class: field- and object-level permissions in server methods, cross-site scripting and CSRF expectations, and accessibility aligned to WCAG 2.1 AA with SLDS 2. Use it during implementation when scaffolding new UI, and again before merge when you want a consistent review pass without missing Salesforce-specific footguns. It pairs well with Apex or integration skills but does not replace org setup or deployment tooling.636installs294React18 Dep CompatibilityReact18-dep-compatibility is a reference skill for solo builders maintaining React apps that use Apollo Client for GraphQL. It explains why Apollo Client below 3.8 breaks under React 18 concurrent rendering—stale cache reads and missed subscription updates—and why 3.8+ is the first line that aligns with useSyncExternalStore. You get a clear version matrix from legacy roots through React 19–tested releases, practical guidance when you are still on ReactDOM.render versus createRoot, and test-focused notes for MockedProvider when async timing changes. Install it when you are bumping React major versions, debugging mysterious GraphQL UI drift, or standardizing dependency upgrades before shipping a SaaS or mobile-web product. It does not replace Apollo migration guides end-to-end but gives your agent citable facts so upgrade PRs and CI failures are traced to the right client version instead of random component refactors.628installs295React18 Batching Patternsreact18-batching-patterns is a focused reference skill from awesome-copilot that explains how React 18 automatic batching breaks common class-component idioms—especially reading this.state immediately after an await. Solo builders maintaining legacy React codebases invoke it when loading spinners stick, initialization steps skip, or conditional setState branches never fire despite preceding setState calls. The skill organizes fixes into categories with concrete before-and-after snippets, emphasizing that intermediate updates may not flush before asynchronous continuation runs. The recommended remediation is often to delete fragile this.state guards and always apply the post-fetch setState in try/catch, which is simpler and correct under batching. It does not replace a full concurrent-features migration guide; it targets one high-frequency defect class during build and ship hardening of existing UIs.625installs296React18 Legacy Contextreact18-legacy-context is an awesome-copilot agent skill that encodes the complete migration path from React’s legacy context API to modern createContext. Solo maintainers upgrading React 18 apps before React 19 need this because context changes are never single-file edits: the provider and every consumer must move in lockstep or the app reads undefined context at runtime. The skill insists you read it before touching contextTypes or childContextTypes, then follow a fixed order—find provider, enumerate all consumers, add the context module, update the provider, then consumers. That cross-file discipline prevents the most common failure mode where only half the tree was migrated. Use it whenever you see class components still wired through getChildContext, especially in older SaaS dashboards or extensions that have not yet adopted hooks-based context providers.622installs297React18 Lifecycle PatternsReact18 Lifecycle Patterns is a migration reference skill from awesome-copilot that gives solo builders copy-paste before/after patterns for retiring componentWillMount in class components. It splits the two common cases: static or computed setState that belongs in the constructor, versus side effects that must move to componentDidMount so fetches and subscriptions do not run in the deprecated pre-mount phase. The skill is aimed at indie teams still maintaining legacy React class code while targeting React 18. Use it when an agent is doing mechanical refactors across a codebase rather than inventing lifecycle rules from memory. Outputs are consistent constructor merges and didMount blocks that align with modern React expectations.621installs298React18 String Refsreact18-string-refs is a pattern library for solo builders and small teams still maintaining class-based React who need to drop deprecated string refs in favor of React.createRef. The skill walks through concrete before-and-after JSX for the common cases: one ref on an input or focus target, and several refs in forms or multi-control widgets. Each example keeps the same component API while renaming this.refs.foo to this.fooRef.current, which aligns with React 18 guidance and avoids silent breakage when upgrading. Use it when an agent is doing a mechanical pass over a legacy repo, when you are unblocking a React 18 bump, or when Copilot keeps suggesting invalid ref="name" syntax. It is reference material rather than a full codemod—pair it with your test suite and lint rules for refs.621installs299React18 Enzyme To RtlReact 18 Enzyme to RTL is a migration skill for solo builders stuck on Enzyme after upgrading React. The SKILL.md states plainly that Enzyme has no React 18 adapter, so every enzyme import must be rewritten with React Testing Library. Before any file edit, the skill forces a mindset change: Enzyme privileged implementation details—wrapper.state, instance methods, prop drilling on shallow trees—while RTL asserts what users see and can activate via accessible queries. It documents full API correspondence but insists those mappings are not mechanical substitutes; tests that only checked internals should be redesigned around rendered text, roles, and disabled state. Invoke it whenever a test file mentions enzyme, shallow rendering, wrapper.find, or simulate clicks on hidden structure. The outcome is a CI-green suite aligned with React 18 and maintainable behavioral coverage rather than copied Enzyme shapes that break on refactors.619installs300Code TourCode Tour is an agent skill grounded in the official CodeTour tour-file JSON Schema. Solo builders use it when they need repeatable, in-editor walkthroughs instead of one-off README tours—onboarding a contractor, explaining a gnarly module before refactor, or packaging architecture context for Claude Code and Copilot. The skill encodes how to structure title, description, branch ref, primary tour designation, chained next tours, step markers, tour-level when conditions, and step lists with required descriptions. That matters for Prism users shipping fast with agents: procedural tour knowledge stays versioned next to source and slots into the Build docs lane while still helping Ship (handoff) and Operate (debugging with context). Complexity is beginner-friendly if you already know your repo layout; the payoff is citable, step-by-step narratives agents can generate without inventing invalid tour shapes.536installs301Prompt OptimizerPrompt Optimizer is a journey-wide agent skill that converts half-formed instructions, pasted drafts, or plain-language task descriptions into one polished prompt you can send unchanged in any LLM chat surface. Solo builders install it to stop losing quality to vague one-liners when they use Claude Code, Codex, Copilot, or similar tools without a separate system channel. The skill assumes the entire instruction must live in the user message, so it emphasizes structure, constraints, and clarity that survive in chat-only workflows. It is not for API request bodies or tool-configuration tuning. Use it in Idea when framing research questions, in Validate when scoping prototypes, in Build and Ship when driving implementation and review, and in Launch or Grow when drafting distribution or support copy—whenever you want a reusable prompt instead of an immediate answer from the optimizer itself.1installs