itallstartedwithaidea/agent-skills
73 skills73 installs1.3k starsGitHub
Install
npx skills add https://github.com/itallstartedwithaidea/agent-skillsSkills in this repo
1Ad Copy GenerationAd Copy Generation is an agent skill from the Agent Skills / googleadsagent.ai line that produces high-performance responsive search ad copy for solo builders and small teams running Google Ads. It generates headline and description sets within Google’s character limits, applies proven frameworks (AIDA, PAS, benefit-led hooks), and scores variants against ad strength criteria. The skill also covers pinning, DKI syntax where appropriate, systematic A/B variants, competitive messaging gaps, pruning underperformers, and scaling statistical winners—so it spans generation through ongoing copy lifecycle, not a one-shot blurb. Install it when you are ready to ship paid search creatives aligned with conversion intent rather than during early idea research.1installs2Adversarial Resilienceadversarial-resilience is an agent skill for solo and indie builders who ship AI agents with tools, filesystem access, or shell execution. As capability grows, so does attack surface: campaign names, ad copy, keyword lists, code comments, and API payloads can carry indirect prompt injection or instructions that hijack the agent’s goals. The skill documents a layered security model—sanitizing inputs, constraining what untrusted text can influence, and preventing escalation beyond intended permissions—grounded in real agent-hardening experience rather than generic security checklists. Use it when designing or reviewing an agent before launch, when integrating new tools, or when user-generated or third-party content flows through the model. It complements secure coding and review skills by focusing on adversarial manipulation of LLM behavior, not only traditional application vulnerabilities.1installs3Agent Instinct SystemAgent Instinct System is an agent skill package that implements pre-cognitive reflexes—automatic safety checks and validations that fire before every code change, tool call, or output generation. Built for high-stakes agent workflows (including Google Ads API operations where a single bad call can exhaust a client budget), it forms a universal safety layer below task-specific logic so invariants stay enforced even when the agent is focused elsewhere. Reflex-tier checks run instantly at near-zero reasoning cost; higher tiers extend deliberate validation for operations that must never slip through. Solo and indie builders shipping with Claude Code, Cursor, or Codex gain a reusable pattern for “always-on” guardrails instead of hoping the model remembers each rule. Use it whenever agents touch production systems, billing, or irreversible filesystem actions, and pair it with explicit task skills so reflexes complement—not replace—domain workflows.1installs4Agent Security ScanningAgent Security Scanning is a Ship-phase skill for solo builders who increasingly ship code written or refactored by agents. Functional tests often green-light behavior while leaving injection, XSS, SSRF, weak validation, and bad crypto in place—patterns studies associate with higher defect rates in AI-generated code. This skill runs a structured scanning mindset across static analysis of the changed codebase, dependency vulnerability checks against CVE knowledge, and threats unique to LLM apps such as prompt injection, tool misuse, and exfiltration via tool calls. Findings are normalized with severity and CWE labels plus actionable fixes, so you can triage in a pre-release pass without pretending a linter alone understands agent habits. It complements your normal CI and human review rather than replacing compliance programs or pen tests.1installs5Ai Chat Studioai-chat-studio is an agent skill from the Agent Skills™ collection that configures a multi-LLM chat framework: hundreds of tested assistant presets, routing logic that matches task shape to model strengths, and unified conversation handling. Solo builders shipping agents or internal copilots use it when one default model wastes money on simple transforms or underpowers reasoning-heavy work like code review and legal-style passes. The skill emphasizes economic routing—fast cheap models for reformatting, mid-tier for translation, reasoning models where quality gates matter—while presets cover code generation, technical writing, data analysis, creative ideation, customer support, and legal review patterns. It fits builders who already depend on Claude Code, Cursor, or Codex but need a structured layer to pick providers per turn instead of always calling the flagship endpoint.1installs6Anthropic Tool MasteryAnthropic Tool Mastery is an agent skill from the Agent Skills collection that treats Claude tool_use as a structured reasoning protocol—not a thin function-calling wrapper. Solo and indie builders shipping with Claude Code use it whenever they need agents to decompose work, fire parallel operations, stream results, and feed outputs through extended thinking without dropping half-finished batches. The skill documents schema-quality habits, parallel dispatch in one turn, composing parallel results, and recovery when some tools fail while others succeed. It reflects patterns exercised in complex agent stacks where several APIs and local tools run together. Use it while designing new skills, refactoring brittle single-tool loops, or leveling up an MVP agent before launch. The payoff is fluency comparable to a senior engineer coordinating tools, which cuts iteration time and reduces silent failures in production agent flows.1installs7Assistant Presetsassistant-presets is a methodology skill for solo builders who ship agent features and are tired of re-pasting slightly different system prompts into every project. It treats an assistant configuration as an artifact: system prompt, temperature and sampling limits, which tools the model may call, how answers must be shaped, and a small benchmark suite that proves the preset behaves before you promote it. That mirrors how product teams version APIs—except the interface is behavior, not HTTP. The skill walks you through defining constraints clearly enough that a legal, medical, ads, or code-review persona does not drift into generic chat, and it emphasizes few-shot exemplars so edge cases are handled consistently. For indie operators, the payoff is faster iteration on customer-facing copilots and internal agents without redeploying application code for every prompt tweak. You will still choose models and hosting yourself; this skill does not replace observability or safety review in production. Use it while building agent surfaces, then reuse the same preset library when you operate and refine assistants based on real user transcripts.1installs8Audience TargetingAudience Targeting is an Agent Skills entry from googleadsagent.ai that teaches agents how to orchestrate Google Ads’ full audience stack for solo founders running their own paid acquisition. Instead of dumping every list into one campaign, the skill explains how in-market and custom intent segments suit upper-funnel prospecting, while customer match and dynamic remarketing lists recover high-intent visitors across web, app, and YouTube surfaces. It highlights Performance Max, where creative automation still depends on strong first-party and intent signals you supply up front. Combined audiences let you express boolean logic when simple exclusions are not enough. Install it when you are past idea-stage validation and need structured audience plans aligned to campaign objectives—not when you only need a single keyword list. It pairs well with landing and pricing validation work earlier, then analytics skills after campaigns run.1installs9Batch Processingbatch-processing is an Agent Skills entry from googleadsagent.ai that teaches agents how to process hundreds or thousands of items—documents, images, code files, or API calls—without treating a production batch like a single chat turn. It emphasizes concurrency caps, backoff when providers throttle you, checkpoint resumes after failures, and clear aggregation of which items passed, failed, or remain pending. Solo builders shipping RAG enrichment, bulk codegen, or multi-modal review pipelines can adopt the patterns when one-at-a-time loops waste time or silently drop errors. The skill covers both uniform operations across every item and routed heterogeneous work by item type, with failed items landing in a dead-letter queue for manual inspection. It fits intermediate builders who already call model APIs and now need operational discipline before Ship-scale runs.1installs10Bioinformaticsbioinformatics is an advanced agent skill from the Agent Skills collection that encodes standard computational-biology workflows solo builders can reuse when shipping scientific products, internal research tools, or data-heavy MVPs. It covers sequence analysis, protein structure prediction, single-cell RNA-seq with Scanpy, gene regulatory network inference, and pathway enrichment—turning raw omics dumps into documented, reproducible steps rather than one-off notebook chaos. The skill reflects how modern experiments outpace manual analysis: scRNA-seq alone can profile tens of thousands of cells across thousands of genes, so the agent emphasizes QC, normalization, dimensionality reduction, clustering, differential expression, and downstream interpretation. It also branches into genomics (variant calling and annotation), proteomics, and systems-biology style networks. Best fit is an indie technical founder or small lab-adjacent team who already works in Python ecosystems and wants agent-assisted pipeline scaffolding—not casual SaaS builders without biology data. Invoke when your product surface depends on credible bioinformatics outputs, not when you only need generic CRUD APIs.1installs11BrainstormingBrainstorming from Agent Skills™ is a journey-wide planning ritual for solo builders who otherwise let the agent start coding on half-formed requests. The skill positions the agent as a senior engineer who probes requirements: it asks about constraints, alternatives, and what you are explicitly not building, then outputs a shared design brief rather than a pull request. That brief becomes the measurable contract for every later phase—whether you are scoping an MVP landing page, choosing between monolith and services, or deciding what to defer past v1. Because it refuses to write code until questioning completes, it prevents expensive mid-sprint reversals when edge cases appear on day three. It pairs naturally with downstream planning skills once the human approves the brief. Prism catalogs it as methodology, not a one-off validator: use it at Idea when the opportunity is still fuzzy, at Validate when specs are thin, at Build when a feature spike needs reframing, and anytime you feel pressure to “just implement” without alignment.1installs12Budget Optimizationbudget-optimization is an Agent Skills entry from the googleadsagent.ai line that helps solo founders and small marketing teams treat a Google Ads account like a portfolio. Instead of nudging budgets campaign by campaign, the skill frames marginal ROAS, efficient frontiers, and business constraints such as minimum brand presence or geographic coverage. It ingests historical performance, seasonality, competitive context, and conversion lag so you can see which campaigns are starved for impressions versus past the point of diminishing returns. Portfolio levers—shared budgets and portfolio bid strategies—get explicit evaluation when conversion volume is too thin per campaign. You reach for it during Grow when monthly spend matters and during Validate when you are proving unit economics on a constrained test budget. It is advisory and analytical: your agent applies the skill’s methodology to your account narrative and constraints rather than silently changing live bids without your review.1installs13CheminformaticsCheminformatics is an agent skill for computational chemistry workflows powered by RDKit. It targets solo builders and small teams exploring drug discovery, materials informatics, or chemistry-aware SaaS who need to turn molecular structures into ranked, testable hypotheses. Use it when you have libraries in SMILES or SDF and must predict properties, run virtual screens, estimate ADMET risk, prepare docking inputs, or map chemical space before committing to synthesis or partnerships. The skill emphasizes reproducible pipelines: parse structures, compute descriptors and fingerprints, search similarity, apply rule-based and model-based filters, and visualize clusters so expensive lab work focuses on diverse leads. It fits the validate phase of the Prism journey when the product thesis depends on molecular data quality, not when you only need a generic CRUD app without chemistry semantics.1installs14Ci Cd PipelinesCI/CD Pipelines encodes production-grade continuous integration and deployment for solo builders shipping Cloudflare Workers and large static or generated sites—patterns drawn from googleadsagent.ai deployments over tens of thousands of pages. The skill goes past “test and deploy” by chaining HTML markup validation, internal link integrity across city × service matrices, JSON-LD schema compliance, and Lighthouse performance audits on every main-branch merge. Deployment follows progressive rollout: promote only after staging passes the full validation cascade, with instant rollback via wrangler rollback. Pull requests get preview environments so regressions surface before production traffic. It fits indie operators who cannot afford silent broken links or schema drift in SEO-heavy content products. Intermediate-to-advanced teams benefit most when Workers, wrangler, and GitHub Actions are already in the stack.1installs15Cloudflare Workerscloudflare-workers is an agent skill for solo builders who want APIs, AI agents, and lightweight SaaS on Cloudflare’s edge instead of a traditional always-on server. It encodes how Workers behave in V8 isolates—stateless routing at the edge plus Durable Objects for coordination—and walks through KV, R2, D1, AI bindings, and Vectorize with patterns drawn from real production Workers. Invoke it when you are implementing backends, integrations, or agent tooling during Build, and again when you Operate or Ship performance-sensitive global deploys. The skill emphasizes constraints agents often get wrong: no filesystem, actor-style state, and binding-first configuration. Intermediate familiarity with HTTP and JavaScript/TypeScript helps; the payoff is architecture that matches Cloudflare’s platform rather than lifted Node monoliths.1installs16Codeql SemgrepCodeQL & Semgrep is an agent skill from the Agent Skills collection that wires production-grade static analysis into coding-agent workflows for solo builders shipping SaaS, APIs, or CLIs. It helps the agent write tailored CodeQL queries and Semgrep rules, execute them against your repository, and explain results with remediation that matches how your app actually uses databases, routes, and error handling. Reach for it when pattern-matching scanners miss data-flow issues, when you need institutional rules like “every route uses auth middleware” or “queries go through our ORM wrapper,” or when you want automated review gates before merge. It spans authoring rules during Build and running enforcement during Ship review. The skill does not replace a full AppSec program or hosted scanning SaaS—it accelerates deep, customizable analysis inside the agent loop when you already have or can install CodeQL/Semgrep tooling.1installs17Code ReviewCode Review is an agent skill from Agent Skills that turns pull request feedback into a repeatable pre-merge quality gate. Solo and indie builders use it when a diff is ready to merge and they need the same rigor a tired human reviewer might skip under time pressure. The workflow starts with a pre-review checklist that blocks semantic analysis until basics like missing tests, linter and type errors, documentation gaps, and stray uncommitted files are surfaced. Only then does the agent evaluate the change against configurable quality dimensions and emit a standardized review document. Every finding is classified as Critical, High, Medium, or Low, with file location, category, description, and a concrete fix suggestion. That record supports mandatory resolution tracking before approval. It fits Claude Code, Cursor, and similar agents when you want checklist-driven evaluation instead of scattered chat comments.1installs18Cognitive ScaffoldingCognitive Scaffolding is a journey-wide agent skill that treats the context window like constrained working memory: language models overweight the start and end of a prompt and under-attend the middle, so arbitrary ordering silently degrades reasoning. The skill teaches you to place must-not-miss constraints, goals, and fresh state where attention peaks, chunk supporting evidence into coherent units, and reserve the closing slice for decisions, checklists, or next actions. Solo and indie builders running Claude Code, Cursor, or Codex benefit whenever a session mixes long files, tool output, and instructions—implementation plans, refactors, ads audits, or support triage. It is methodology, not a hosted API: you restructure what you already paste or retrieve. Use it before heavy reasoning passes whenever accuracy dropped and you suspect context noise rather than model limits.1installs19Competitor AnalysisCompetitor Analysis is an agent skill from the Agent Skills collection focused on Google Ads auction data. Solo and indie builders running paid acquisition use it to move past raw Auction Insights exports into structured competitive intelligence across campaigns and keywords. The workflow profiles who appears next to your ads, how often overlap rises, and when rivals push harder on position-above and impression share. It also ties ad preview and copy signals to offer and USP patterns, then links share metrics to actionable keyword and budget hypotheses. It fits early in the journey when you are sizing rivals, validating positioning, or planning spend—not when you only need on-page SEO or organic keyword tools. You supply auction insights and related Ads context; the skill emphasizes interpretation and narrative intelligence rather than connecting unrelated ad APIs by itself. Review the skill package and any credentials handling before running against live account exports.1installs20Composition PatternsComposition Patterns is an agent skill that teaches flexible, maintainable React UI by using compound components, lifting shared state, composing internally, and delegating render slots instead of multiplying boolean flags. Solo and indie builders shipping SaaS or browser extensions with Claude Code, Cursor, or Codex hit a wall when one component accrues dozens of toggles—each boolean doubles effective state space and makes every change a surgery on internals. The skill frames the anti-pattern explicitly and walks agents through four complementary techniques so consumers assemble UI from smaller pieces while shared behavior stays in the right layer. Use it during frontend implementation whenever an agent proposes another `showX` or `enableY` prop, or when a design needs headers, footers, loading states, and variants without forking the base component. It is editorial guidance and procedural knowledge, not a CLI or MCP server; confidence is high for React codebases and lower if you are not on React.1installs21Configuration ManagementConfiguration Management is an Agent Skills™ package from googleadsagent.ai that teaches agents how to implement dynamic, hot-reloadable configuration the way mature platforms do with Nacos-style control planes. Solo builders shipping SaaS or APIs often start with static .env or YAML files, which forces a full deploy whenever a rate limit, feature flag, or routing rule changes—adding risk and delay on live traffic. This skill walks through defining validated configuration schemas, storing authoritative versions centrally, notifying application instances when values change, caching on the client with sensible TTL, and rolling back to any prior revision with auditable change history. The mental model treats every parameter update as an operational event distinct from shipping new code. It is most valuable once you have something in production that must be tuned frequently, but the same patterns help during Build when you architect the config client and during Ship when you harden launch-time toggles. Expect intermediate backend or DevOps comfort because you will wire subscribers, validation, and notification paths into your runtime.1installs22Context EngineeringContext Engineering is an agent skill that teaches procedural discipline for maximizing output quality while minimizing token spend. Solo builders shipping with Claude Code, Cursor, or Codex install it when long sessions, large repos, or stacked skills start to bloat the window and degrade answers. The skill frames context as engineered working memory—not a dump of everything available—and codifies density optimization, staged loading, and progressive disclosure so instructions and facts arrive when they matter. It addresses the production gap between demo agents and systems that stay on-spec under cost and latency pressure. Use it whenever you are composing prompts, chaining skills, or designing agent workflows, not only during initial integration setup. Poor context engineering shows up as hallucination and drift; this skill gives repeatable patterns to audit and tighten what the model actually sees.1installs23Continuous Learningcontinuous-learning is a meta skill for solo builders who treat their coding agent as a product that should get smarter over time. Instead of manually writing SKILL.md files after every win, the skill describes a flywheel: observe session logs, extract patterns that correlated with good outcomes (tool order, prompt edits, recovery paths), codify them into structured skills or rules, and wire those assets back into later invocations. It is journey-wide because the same learning loop applies whether you are validating ads workflows, shipping integrations, or operating on recurring errors—any session can donate patterns. The documentation ties to Agent Skills and Buddy-style mining that produced specialized techniques without explicit human programming. Expect intermediate operational overhead: you need logging discipline and review before auto-generated skills land in repo. It complements skill-creator eval workflows but focuses on runtime session mining rather than benchmark harnesses.1installs24Conversion TrackingConversion Tracking is an agent skill from the Agent Skills collection focused on Google Ads measurement infrastructure for solo founders and small teams running paid acquisition. Accurate conversion data is what makes Smart Bidding, budget shifts, and keyword valuation honest; this skill walks setup, validation, debugging, and attribution across the Google tag, enhanced conversions, offline conversion imports, and conversion value rules. It distinguishes macro goals that should drive bidding from micro signals that inform audiences and funnel diagnostics, and it aligns counting methods and lookback windows with how your business actually closes revenue. Enhanced conversions using hashed first-party identifiers help recover signal as cookies thin out. Attribution work emphasizes configuring and comparing data-driven attribution rather than guessing from last-click reports alone. Use it when campaigns are live or about to go live and measurement—not creative—is the bottleneck. Intermediate complexity assumes comfort with Google Ads UI, tagging concepts, and compliance basics for customer data.1installs25Data AnalysisData Analysis is an agent skill from Agent Skills that treats statistical work as a disciplined workflow rather than one-off scripts. It guides your coding agent through ingestion and cleaning, exploratory analysis, assumption-aware hypothesis testing, and visualization using pandas, numpy, scipy, matplotlib, seaborn, and plotly. Solo and indie builders use it when they need defensible numbers for investor updates, A/B readouts, market sizing, or internal dashboards without skipping steps that auditors or reviewers expect. The skill pushes reproducibility at every transformation, justified methods, and figures that match scientific norms—proper units on axes, accessible colors, and export formats suitable for decks or papers. It fits naturally after you have a dataset on disk and before you commit narrative conclusions to a landing page, pitch, or product spec.1installs26Database LookupDatabase Lookup abstracts the complexity of querying 78+ scientific and public databases—from chemistry (PubChem, ChEMBL) and biology (UniProt, COSMIC) to clinical trials and economic indicators—into a single unified interface. You use it when building research tools, data pipelines, or AI agents that need to pull compound properties, protein sequences, clinical data, or patent information from multiple sources. It handles authentication, response normalization, caching, and rate limiting automatically, enabling reproducible, multi-source research workflows without manual API integration.1installs27Edge DeploymentEdge Deployment is an Agent Skills™ package that automates taking a frontend repository from “build succeeds locally” to “running on Vercel or Cloudflare” with minimal manual platform trivia. It targets solo and indie builders who ship SaaS dashboards, marketing sites, and hybrid SSR apps and do not want to memorize each framework’s default install, build, and output settings across two major edge hosts. The skill inspects the project, infers the framework from a broad catalog, selects an appropriate static or server-rendered strategy, wires environment variables per stage, and walks through preview and production promotion patterns tied to git workflow. It explicitly accounts for how Vercel’s serverless functions differ from Cloudflare Workers constraints so the agent does not paste the wrong runtime assumptions. Beyond the first deploy, it covers custom domains and ongoing environment management so repeat releases stay boring. Use it when the product code is ready and the blocker is reliable, repeatable edge hosting—not when you still need feature implementation or load testing in isolation. It pairs naturally with CI-oriented habits: PR previews for validation and merge-to-main1installs28Edge RenderingEdge Rendering is an agent skill for solo builders who need programmatic SEO and localized landing pages without maintaining a huge static site or a slow origin render path. It describes generating HTML at the network edge—using Workers-style compute, edge KV for locality data, and D1 or similar stores for service metadata—so each URL in a city × service (or analogous) matrix gets unique copy, structured data, and meta tags on first request, then serves from cache globally. The pattern fits indie SaaS, agencies, and marketplaces that must rank many long-tail location or category URLs without a dedicated content team pre-publishing every combination. Use it when content follows repeatable templates but variants matter per city, segment, or SKU. It pairs with Ship and Operate concerns (cache semantics, data freshness) but primary value is Launch-phase discoverability and crawlable surface area at scale.1installs29Entity Memory ManagementEntity Memory Management is a journey-wide agent skill from Agent Skills by googleadsagent.ai that teaches systematic extraction, persistence, and retrieval of named entities across sessions. Instead of compressing conversations into lossy summaries, it models discrete objects—campaigns with strategies and budgets, metrics with historical values, decisions with outcomes, and user preferences—so agents answer with specificity. The approach mirrors production systems operating at scale for Buddy, where thousands of entities survive across hundreds of user sessions. Solo builders shipping customer-facing agents gain durable context for growth analytics conversations, support triage, and ongoing account management without re-asking the same background questions. Install when you are implementing or hardening agent memory beyond ephemeral context windows. It complements generic RAG by anchoring memory on stable entity IDs and types your product domain already uses.1installs30Executing PlansExecuting Plans is an agent skill for disciplined batch execution of written plans. Solo builders and small teams use it when multi-file or ordered changes must not be improvised in chat: the agent walks the plan in sequence, runs verification after each step, and stops on failure instead of silently drifting. Human checkpoints give lightweight oversight without micromanaging every edit, while rollback records state before each step so a bad deploy or bad refactor can be reverted or retried with clear options. It pairs naturally with plan-writing skills in Agent Skills-style stacks—approved spec first, then this skill as the execution contract. Expect intermediate complexity: you need a real plan, explicit verification commands, and willingness to pause at gates. The outcome is traceable progress through complex work rather than wishful “mostly done” threads.1installs31Geospatial AnalysisGeospatial Analysis is an Agent Skills™ package for solo builders and small teams shipping location-aware products, research notebooks, or internal geo tools. It teaches agents to treat spatial data correctly—coordinate reference systems, scale-dependent patterns, and spatial independence—while wiring Sentinel and Landsat multispectral steps together with vector sources like shapefiles and GeoJSON. Typical flows move from raw Earth observation rasters through classification or change detection into vector summaries and maps suitable for reports or APIs. Use it when you are past vague maps-in-a-slide and need scripted, repeatable geographic intelligence during product build, or when validation work needs defensible spatial methods before you commit to a data model. The skill is advanced: expect Python, GeoPandas, and domain literacy around CRS and autocorrelation. It complements generic data-science skills by encoding GIS-specific pitfalls so agents do not treat lat/long like ordinary columns.1installs32Git Worktreesgit-worktrees is an agent skill from Agent Skills™ that teaches how to use Git worktrees for parallel development. Instead of constantly stashing and switching branches, you spin up a dedicated directory per task or subagent, each tied to its own branch, so work stays isolated until you merge. Solo builders running multiple Claude or Cursor agents on different features benefit most: one agent can refactor auth while another fixes tests, without sharing a single dirty working tree. The skill also explains using fresh worktrees as pristine environments to confirm tests pass without leftover build output or config drift. Lifecycle discipline—create when a task starts, verify when it finishes, prune after merge—keeps disk use and branch clutter under control. It pairs naturally with planning and review workflows but is fundamentally a git ergonomics pattern for high-parallel agent coding.1installs33Google Ads AuditGoogle Ads Account Audit is a checker-style skill for solo builders and small teams running Search, Shopping, Performance Max, Display, Video, or remarketing campaigns who lack time to manually walk every settings screen. It applies a large pattern library encoding anti-patterns, thresholds, and best-practice violations gathered from many real accounts, then scores issues and stacks recommendations by likely revenue impact. Categories span campaign structure, audiences, landing pages, automation, competitive strategy, and policy compliance so you get a roadmap instead of a generic checklist. It aligns with agent-assisted growth ops where you want repeatable audits before budget increases or channel expansion. Pair it with your own conversion data access and human judgment on brand and legal constraints—the skill structures analysis; you still approve changes in Google Ads.1installs34Keyword ResearchKeyword Research is an Agent Skills package skill from the googleadsagent.ai lineage that teaches agents a repeatable Google Ads keyword workflow. Starting from seed terms, it expands coverage through semantic variants, competitor keyword mining, search term report analysis, long-tail discovery, and intent-based grouping so campaigns map to how buyers actually search. Match type selection is treated as economics: each keyword is weighed against conversion likelihood, volume, competition, and CPC before recommending broad, phrase, or exact match, including when to lean on smart bidding with broad match. Negative keyword management mirrors the expansion work—irrelevant queries from STRs become structured negatives at account, campaign, and ad-group tiers. Solo and indie builders shipping products with limited ad budgets use it when they need agent-guided rigor instead of dumping everything into one match type or skipping negatives until spend balloons.1installs35Knowledge Base Injectionknowledge-base-injection documents how to dynamically inject specialized expertise into an agent only when a task needs it, using TF-IDF pattern matching and semantic scoring. Solo builders shipping vertical agents—ads, compliance, medical coding, finance—often hit a wall: general models miss niche rules, fine-tuning is costly, and dumping every rule into the system prompt wastes tokens and blurs attention. This skill explains the injection technique and ties it to a production knowledge base powering Buddy™ at googleadsagent.ai, where gads-knowledge.js holds more than one thousand Google Ads patterns, each with triggers, recommendations, evidence, and confidence. Use it journey-wide whenever you design retrieval, scoring, or context assembly for agents in Claude Code, Cursor, or Codex workflows. It is methodology and architecture guidance, not a drop-in MCP server; you still implement storage, scoring, and prompt assembly in your repo.1installs36Knowledge Base Ragknowledge-base-rag is an agent skill that walks solo builders through implementing Retrieval-Augmented Generation for private corpora. When your product must answer from policies, docs, or support archives that never appeared in base model training, plain prompting fails; this skill sequences ingestion, chunking, embedding, indexing, semantic retrieval, and citation-aware generation so responses stay factual and attributable. It stresses that chunking beats model shopping for quality: semantic chunks that respect paragraphs, recursive splits that honor headings and code blocks, and overlaps that preserve continuity across segment boundaries. The audience is builders shipping agent features or internal copilots, not marketers tuning distribution. Expect integration decisions around vector databases and embedding APIs during Build, with operational tuning later. Use it when you are ready to wire data paths and retrieval policies, not when you are only validating whether RAG is the right approach on a napkin prototype.1installs37Landing Page Auditlanding-page-audit is an agent skill from the Agent Skills / googleadsagent.ai line that evaluates post-click experiences as a unified technical and conversion problem. Solo builders running Google Ads or similar paid channels use it to measure Core Web Vitals—LCP, INP (and FID context), and CLS—across devices, spot render-blocking assets, and prioritize fixes that affect landing page experience signals. In parallel it audits relevance between ad copy and on-page messaging, CTA prominence, form design, and persuasion patterns that determine whether traffic becomes revenue. The output is structured around speed, relevance, and persuasion so you can ship landing changes before burning budget on a weak URL. It fits indie SaaS and ecommerce founders who own both the page and the campaign and need CRO-grade critique without hiring a full agency audit.1installs38Long Horizon WorkflowsLong-Horizon Workflows is a journey-wide agent skill for solo builders who want autonomous runs that last hours—not minutes—without gambling the entire job on a single brittle thread. It describes how to decompose a large objective into staged execution plans, persist checkpoints so a failure at hour two does not erase hour one, surface progress for sanity checks, recover from errors gracefully, and pause for human validation before high-impact actions. The documentation ties these patterns to DeerFlow-style architecture and real-world scales such as analyzing dozens of campaigns and thousands of keywords before emitting optimization reports and implementation-ready change sets. That makes the skill relevant when you are still researching automation approaches in Idea, scoping a Validate prototype that must run overnight, building Ship-ready agent infrastructure, or operating Grow workflows that re-scan accounts on a schedule. Reliability is framed as the core product requirement: a partial failure without recovery is worse than no automation. This is methodology and orchestration guidance—not a hosted runtime—so you still implement storage, queues, and auth in your stack.1installs39Low Code GenerationLow-code generation teaches an agent to produce production-ready UI from natural language or schema definitions, sliding along a spectrum from declarative JSON configurations to bespoke React. Solo builders use it when admin panels, internal tools, or SaaS dashboards would take days to hand-code but do not all need custom visualization stacks. The skill encodes when a configurable table or form schema is enough versus when full code is justified for conditional multi-step flows or custom analytics. It fits agent-skills collections aimed at accelerating Build without abandoning maintainability. You still own data contracts, auth, and API wiring; the skill focuses on component selection, validation rules, and server-side table operations patterns. Intermediate users get the most value when they can review generated JSX or config for security and accessibility gaps.1installs40Machine Learningmachine-learning is an agent skill from the Agent Skills collection aimed at builders who have working notebooks but need production-minded ML discipline. It directs agents to construct full pipelines: model selection, training, evaluation, hyperparameter tuning, and experiment tracking using PyTorch and scikit-learn. The skill stresses software engineering habits—version-controlled experiments, deterministic training, and interpretable outputs—so you can reproduce results months later. Interpretability is mandatory: SHAP, feature importance, and partial dependence explain what the model learned. Solo founders shipping prediction features, ranking, or classification into a SaaS backend benefit most when they lack a dedicated ML platform team. Use it during build when implementing models, and again in ship when you need rigorous validation evidence before release.1installs41Mcp Server CreationMCP Server Creation teaches solo and indie builders how to implement Model Context Protocol servers that expose tools, resources, and capabilities through one standard interface any compliant agent can use. Instead of wiring Claude Code, Cursor, Codex, and future clients separately, you publish an MCP server and let clients discover and invoke your functions with structured schemas. The skill emphasizes production-quality patterns on Cloudflare Workers: TypeScript handlers, edge deployment, OAuth and token handling for APIs like Google Ads, rate limits, and tenant isolation—drawn from the live Buddy™ agent stack at googleadsagent.ai. It fits builders shipping agent products, internal automation, or SaaS features that need reliable, documented tool access. Use it when you are ready to code and deploy the integration layer, not when you only need to install an existing marketplace server. Expect intermediate-to-advanced systems thinking around auth, quotas, and operational safety at the edge.1installs42Memory PersistenceMemory Persistence is an agent skill that teaches how to save critical context when a session ends and reload it when a new one begins, so agents behave as if they have continuous memory. Without it, every conversation resets: preferences vanish, prior analyses are lost, and corrected errors resurface. The skill documents hook-based workflows and storage keyed by user and session, with retrieval of the most relevant prior memories injected into the prompt. It is grounded in a production system using Cloudflare KV for entity extraction, session summaries, and selective recall. Solo builders shipping custom agents or long-running Claude Code workflows use it in Idea research notes, Build integrations, Ship review context, and Operate incident follow-ups whenever the same agent should accumulate institutional knowledge safely.1installs43Ml Model IntegrationML Model Integration encodes how a solo builder navigates HuggingFace Hub without drowning in architecture jargon or picking a model that violates license or GPU budget. The skill walks discovery—filtering by task such as summarization, classification, or speech—and forces explicit tradeoffs on size, license, and hardware before you commit. Evaluation covers running inference on representative data and recording latency and quality so you can justify a choice in a one-person roadmap. Deployment branches cover the pragmatic paths indie teams use: a local Transformers pipeline for dev, managed Inference API for fast ship, or TGI/vLLM when you need control and throughput. Fine-tuning via LoRA adapters is included for domain-specific tweaks without renting a cluster for weeks. Pair it with your backend or agent-tooling skills when exposing models as API routes or tool calls in Claude Code or Cursor.1installs44Multi Harness PortabilityMulti-Harness Portability is an engineering discipline skill from Agent Skills™ that teaches solo builders and small teams how to write agent skills, prompts, and configuration so they survive editor and CLI fragmentation. The landscape splits across Claude Code, Cursor, Codex, Gemini CLI, OpenCode, and more; platform-locked skills become maintenance debt while portable skills reuse the same procedural knowledge everywhere. The skill emphasizes abstraction layers that translate harness-specific capabilities—hooks, rules, instructions, system prompts—into a consistent skill contract, with thin adapters per platform handling the differences. Invoke it whenever you are designing a new SKILL.md, migrating rules from one tool to another, or standardizing a shared skill library before anyone commits to a single vendor. It pairs naturally with other meta skills in the same repo when you want one source of truth for agent behavior across your whole toolchain.1installs45Multi Model RoutingMulti-Model Routing is an agent skill for solo builders and small teams running production agents who cannot afford one flagship model on every hop. It explains how to dispatch work to Claude for hard reasoning, GPT-4o for strong tool use, Gemini for large cheap context, and open-source options where appropriate, with graceful failover when APIs blink. The doc ties architecture to real ops: task classification, provider tiers, and quality parity on “easy” subtasks like formatting and summarization. Install it when you are wiring agent orchestration, tuning inference bills, or hardening availability before launch. You get a repeatable routing design—not a single API wrapper—so agents stay resilient and cost-aware as traffic grows.1installs46ObservabilityObservability is an agent skill for solo builders shipping on Cloudflare Workers and other edge runtimes where there is no long-lived process, log directory, or sidecar APM. It walks your agent through the three pillars—structured logging as JSON events with correlation IDs, distributed tracing with request-scoped spans, and monitoring with error rates, latency percentiles, and alerting rules—so you can answer what happened, how long it took, and how often it fails. Use it while you are still wiring handlers in Build and keep the patterns as you move into Operate. The skill emphasizes shipping observability in the application layer and forwarding events to external collectors without sacrificing Worker performance. It fits indie SaaS and API products that need production debugging discipline without a full platform team.1installs47Parallel Agent Orchestrationparallel-agent-orchestration teaches solo builders and small teams how to run multiple subagents at once instead of serial chat loops. The skill belongs to the Agent Skills ecosystem and documents orchestration used in production—for example one subagent on bidding, another on keywords, and a third on creative quality—then merges results upstream. Install it when complex reviews, multi-file refactors, or multi-source research dominate your timeline and subtasks do not depend on each other’s partial outputs. Primary placement is Build and agent-tooling because you wire dispatch, timeouts, and aggregation into your agent harness; the same discipline helps Ship reviews and Grow analytics where parallel file or campaign passes are common. Intermediate to advanced readers get framing on decomposition, aggregation, and quality parity versus single-agent depth.1installs48Pmax OptimizationPerformance Max Optimization is an agent skill from the Agent Skills and googleadsagent.ai lineage aimed at solo founders and marketers who run Google Ads but struggle to steer Performance Max’s opaque automation. PMax blends inventory across Search, Display, YouTube, Discover, Gmail, and Maps; Google handles much delivery, yet advertiser inputs—asset group architecture, creative quality, audience signals, URL expansion rules, and search themes—largely determine whether spend scales efficiently or bleeds budget. The skill frames PMax as a black box you influence structurally: map asset groups to offers or segments, seed signals that accelerate learning without choking reach, lock down URL expansion where brand safety matters, and use search themes to nudge Search appearances. It also emphasizes ongoing asset rating hygiene (Best, Good, Low) so underperforming creative gets replaced before ROAS decays. Install it when you already run or plan PMax and need expert playbooks in-agent instead of generic Google help articles.1installs49Proactive IntelligenceProactive Intelligence is an agent skill that trains assistants to close knowledge gaps on their own while they analyze a problem. Instead of stopping when the prompt’s data runs out, the agent recognizes when information is missing, outdated, or inconsistent and independently runs web searches, API re-pulls, or freshness checks. The pattern comes from production ad-agent workflows where campaigns need live competitor data, industry benchmarks, and policy updates when metrics look unusual. Solo and indie builders shipping agent-powered SaaS or internal copilots install it when reactive-only agents feel shallow—wrong recommendations because the model never verified current facts. Use it whenever analysis quality depends on external reality, not just the files in the repo. It pairs well with tool-enabled Claude Code, Cursor, or Codex setups where you can grant network access responsibly.1installs50Programmatic VideoProgrammatic Video is a generator-oriented skill for solo builders who want reproducible marketing and product video without Adobe timelines. It centers on Remotion: compositions receive frame and durationInFrames, scenes nest inside Sequence wrappers, and spring animations keep motion consistent. The agent helps you treat video like software—templates in git, props swapped per customer or campaign, snapshot tests where you use them—so one codebase can render thousands of variants. It pairs naturally with motion specs and review skills when you already document palette and scene timing elsewhere. Typical outputs include onboarding walkthroughs, personalized demos, and short social cuts driven by JSON or CMS data rather than hand editing each export.1installs51Prompt Architectureprompt-architecture teaches structural engineering for agent instructions: how to compose system-level invariants, task-specific user layers, and assistant priming so outputs stay deterministic when workloads grow. Casual prompt writing collapses under edge cases; architectural design propagates constraints, enforces schemas, and scaffolds reasoning so the same skill behaves predictably across thousands of runs. The skill positions prompts as programs with an explicit execution model rather than prose you paste once. Solo builders shipping Claude Code or Cursor agents, internal copilots, or multi-step analyzers use it whenever behavior drifts, formats break, or safety boundaries leak between turns. It pairs naturally with skill authoring and review work—you architect before you implement features, and you revisit architecture when evals show regression. Invoke it before committing a major SKILL.md rewrite, when standardizing team prompt templates, or when debugging inconsistent tool-use or JSON output from otherwise identical inputs.1installs52Quality Score OptimizationQuality Score Optimization is an agent skill for solo and indie builders who run Google Ads and need a repeatable way to raise relevance scores instead of tweaking ads blindly. Google’s 1–10 Quality Score gates ad rank, CPC, and impression share; small gains can materially lower costs. The skill walks through each keyword’s three sub-scores—expected CTR, ad relevance, and landing page experience—and recommends concrete changes aligned with the weak component. It also emphasizes longitudinal tracking so you see degradation early and correlate it with creative, landing-page, or structure changes you made. Spend-weighted prioritization keeps limited time on keywords that actually move budget. Use it when accounts feel “fine” but CPCs creep up, when new landing pages ship, or when you scale budgets and need confidence that relevance will hold.1installs53React Best PracticesReact Best Practices is an agent skill from the Agent Skills collection that encodes more than forty React performance rules grouped into eight priority categories. Solo and indie builders shipping SPAs, dashboards, or React Native–adjacent web apps install it when performance regressions show up late—or when they want review guardrails before launch. The agent uses the skill while drafting or auditing React code, surfacing Critical fixes such as eliminating request waterfalls and shrinking bundles before Medium-tier re-render tweaks that rarely move real user metrics. Rules are ordered by measured impact, not implementation convenience, which helps time-boxed founders focus on network and load-path wins first. It pairs naturally with code review and pre-ship performance passes on Claude Code, Cursor, or Codex without replacing profiling tools or production RUM.1installs54React Native GuidelinesReact Native Guidelines is an agent skill that encodes cross-platform mobile discipline for solo builders shipping React Native apps with Claude Code, Cursor, or similar agents. It codifies sixteen rules in seven sections—Performance, Layout, Animation, Images, State, Architecture, and Platform—each mapping to a concrete failure mode in React Native’s bridge and native rendering pipeline. Unlike web React guidance, it stresses keeping the JavaScript thread unblocked, animating with the native driver, tuning list virtualization, and reducing async chatter between JS, UI, and native module threads. Invoke it when you scaffold screens, refactor navigation, or chase jank on iOS or Android. The skill reads as a checker-style rulebook agents can apply during implementation and review. It pairs well with performance tuning in Ship when production metrics slip, but its canonical home is Build frontend work where architectural choices are cheapest to fix.1installs55Remarketing StrategyRemarketing Strategy is an agent skill for solo and indie builders who already drive traffic but leak conversions at every funnel step. It designs cross-channel remarketing architectures that re-engage users based on engagement depth—not flat “past visitor” lists. The workflow walks through audience tiers from casual browsers to cart abandoners and existing customers, then aligns creative and bidding tactics to each relationship stage. Cross-channel execution covers Display, YouTube, Remarketing Lists for Search Ads, and dynamic product feeds so small teams can orchestrate messaging without a dedicated performance agency. Use it when you are scaling paid ads after launch and need structured list logic, sequential messaging, and ROI-focused retargeting instead of one-size-fits-all remarketing tags. It fits growth-focused SaaS, ecommerce, and content products where repeat visits are cheaper than cold acquisition.1installs56Research MethodologyResearch Methodology is an agent skill from Agent Skills™ that walks solo builders and small teams through a full scientific research workflow inside the coding agent. It covers turning literature gaps into falsifiable hypotheses, designing experiments with proper controls and power thinking, running structured literature reviews with Boolean search and citation hygiene, defining data collection protocols, and packaging work for peer review. The skill is built for indie researchers, data-heavy side projects, and builders who use agents for literature synthesis or study design—not for one-click chart generation. Use it when methodology mistakes would invalidate everything downstream, regardless of how polished the analysis looks. It complements generic web-research skills by enforcing controls, sample-size reasoning, ethical-review readiness, and reproducibility at each step. Intermediate complexity: you need a real question, access to sources, and willingness to revise design when the agent flags weak inference.1installs57Sandbox Hardeningsandbox-hardening is an agent skill package for configuring and validating isolated execution environments where AI-generated code runs. Solo builders shipping agent products, internal dev tools, or multi-tenant platforms use it to translate abstract security goals into concrete sandbox profiles: seccomp and AppArmor at the process layer, hardened Docker with dropped capabilities at the container layer, and microVM isolation when trust is low. The workflow walks the agent through permission boundaries, CPU and memory ceilings, filesystem mounts, and monitored egress so a single bad prompt cannot delete host files, leak secrets, or fork-bomb a server. Complexity is advanced because you must match isolation depth to your threat model—development assistants differ from arbitrary user code runners. The skill is procedural security engineering for agentic systems, not a one-click hosted sandbox product.1installs58Scientific Writingscientific-writing is an Agent Skills skill for solo builders and indie researchers who must ship credible research artifacts—papers, abstracts, grant proposals, and supplements—with journal-grade mechanics. It treats scientific writing as functional prose: context, evidence, conclusions, and limitations each have a place within IMRaD and funder expectations. The skill steers citation hygiene via BibTeX, LaTeX formatting for math and figures, statistically legible tables, and passive-to-active voice balance appropriate to modern venues. Agents use it when a validate-stage prototype needs a methods section, when build-stage docs must become a manuscript, or when launch-adjacent preprints require compliant reference styles. It deliberately excludes casual blogging and unsupported claims, favoring checkable statements tied to your data and prior work.1installs59Secret ProtectionSecret Protection is an agent skill for solo builders and small teams who ship code and use AI agents daily and cannot afford a leaked key in a public repo. It implements a zero-tolerance stance on credentials in source, configuration, logs, or chat history, with interception at pre-commit, in CI/CD when hooks are bypassed, and at runtime when secrets appear in errors or agent replies. The SKILL.md emphasizes that automated scanners target GitHub quickly after exposure, so prevention beats cleanup. Practically, the agent guides .env hygiene, hook setup, rotation expectations, and redaction patterns so each ring can catch what the previous one missed. Use it while wiring repos, tightening ship checklists, or hardening agent workflows that might echo environment variables. It complements broader audits by focusing on the most common breach vector—committed secrets—rather than generic threat modeling alone.1installs60Self Healing Agentsself-healing-agents teaches solo builders how to ship autonomous agents that expect failure and recover without paging a human. The skill argues that timeouts, schema changes, rate limits, and confident hallucinations are normal in production, and separates demo agents from dependable ones by how they classify errors and respond. It documents a detect-diagnose-repair loop analogous to immune response: recognize the failure mode, categorize the threat, and apply the right countermeasure. That includes mutating strategy instead of repeating the same call, selecting fallback models, and validating or repairing outputs when assumptions break. Builders typically apply it while hardening agent backends before launch and while operating live workflows that must finish even when upstream Google Ads or similar APIs misbehave. It complements basic retry configuration with explicit repair logic so analytics and action agents complete reliably.1installs61Service Discoveryservice-discovery is an Agent Skills entry from itallstartedwithaidea that explains how cloud-native apps replace brittle hardcoded service URLs with a living registry. Solo builders running multiple APIs, workers, or edge nodes learn self-registration on startup, continuous health verification, and consumer-side instance selection—the same conceptual stack popularized by Nacos-style systems. The skill is architectural and procedural rather than a single-vendor install script: it helps you and your coding agent reason about registration payloads, liveness signals, and discovery clients before you commit to Consul, Eureka, Nacos, or a managed mesh. Use it when topology changes often—autoscaling, multi-region, or frequent redeploys—and you need failover and routing to follow reality. It complements Build backend service design and Operate monitoring because registry health is both an integration contract and a production signal. Intermediate builders comfortable with HTTP services and containers get the most value; it is not a substitute for reading your chosen registry’s official SDK docs end to end.1installs62Session ArchaeologySession Archaeology is an agent skill for solo builders and small teams who already run Claude Code, Cursor, or similar agents and want those runs to compound instead of disappearing. It treats each session transcript as domain-specific training data: you systematically review reasoning steps, tool usage, failures, fixes, and final outcomes to see what actually worked in your codebase and workflows. The skill guides you from raw logs through pattern extraction, failure-mode clustering, and packaging insights as reusable procedural knowledge in new or updated skills. It fits whenever you have enough session history to learn from—after shipping features, during support-heavy periods, or while scaling agent-assisted ops—not only at greenfield build time. For Prism’s audience, it is the meta-layer that turns directory-installed skills into skills tuned to how you really ship.1installs63Shopping AdsShopping Ads is an agent skill from the googleadsagent.ai Agent Skills collection for solo builders and small teams selling physical or catalog products on Google. It treats Merchant Center feed quality as the non-negotiable foundation: every required attribute is checked against Google policies and practical merchandising norms, then titles and descriptions are tuned so queries map to long-tail product language users actually type. Custom labels turn catalog data into bidding segments so you can protect margin on low performers and push budget toward proven SKUs. On the campaign side, the skill guides Shopping structures—priority splits, listing groups, and bid logic—that keep queries from cannibalizing each other. Unlike generic PPC advice, it stays inside the Shopping format where image, price, and merchant name pre-qualify clicks. Use when you are launching or growing an ecommerce store, migrating from manual Ads UI work, or fixing weak ROAS that traces back to thin feeds rather than bid tweaks alone.1installs64Subagent Driven DevelopmentSubagent-Driven Development is a multi-phase agent methodology for solo builders who ship substantial features through long Claude Code or Cursor sessions. Context window contamination—faded instructions, wrong file references after refactors—is a common silent quality killer; this skill institutionalizes giving every discrete task a clean implementer subagent that sees only the spec and needed files. The orchestrating agent breaks work into atomic pieces, writes tight task specs, and merges only after dual review: first whether the deliverable matches the ask, second whether the code is testable and maintainable. You will use it most while building agent-forward products, but the same gate applies when you are in Ship doing pre-merge review on agent output. It pairs well with planning skills upstream and security or code-review skills downstream when those are part of your stack.1installs65Systematic DebuggingSystematic Debugging is a journey-wide agent skill from Agent Skills by googleadsagent.ai that stops trial-and-error patching. The agent must reproduce the bug reliably, rank hypotheses, instrument and test one variable at a time, and only then apply a targeted fix—articulating the causal chain before writing corrective code. That rigor matters for solo builders who cannot afford regressions from multi-file guesswork. After the fix, the skill expects defense-in-depth: assertions, validation, or monitoring that catches the same bug class again, plus a short post-mortem for future you and your agent. Invoke it when tests fail, users send stack traces, or behavior diverges across environments. It complements ship-time QA and operate-time incident response without replacing dedicated security audits or feature planning skills.1installs66Test Driven DevelopmentTest-Driven Development is an Agent Skills package skill that locks coding agents into classic TDD instead of dumping large untested blocks that look plausible but fail on edge cases. Solo and indie builders shipping with Claude Code, Cursor, or Codex invoke it whenever the agent will add or change behavior: new functions, modules, bug fixes, or refactors. The workflow is explicit—RED (failing test you can see fail), GREEN (smallest code to pass), REFACTOR (clarity without changing behavior)—and each loop ends in version control as an atomic commit. That turns coverage from a late audit into a structural guarantee because code only exists to satisfy assertions the agent already wrote. It pairs naturally with planning and review skills: after a spec is approved, TDD is how implementation stays honest under automation. The skill does not replace your test framework choice; it governs agent behavior so discipline survives fast iteration.1installs67Token OptimizationToken Optimization is an agent skill that teaches systematic reduction of token use across agent operations while preserving output quality. Solo builders and small teams running Claude Code, Cursor, or similar agents in production face rising API bills and slower turns when prompts, model choice, and repeat work are left unoptimized. The skill organizes work across model selection (right-sizing capability to task complexity), prompt compression (removing redundant instruction tokens), background processing (moving expensive steps off the hot path), and caching (reusing results for identical or near-identical inputs). It reflects practices from high-traffic agent ecosystems and production ad-analysis platforms that must stay inside strict daily budgets. Install it when you are shipping or operating agent features—not when you only need a one-off script—and want repeatable patterns instead of ad-hoc shorter prompts. It pairs naturally with monitoring and iteration work in Operate and with agent-tooling choices during Build.1installs68Verification LoopsVerification Loops teaches solo and indie builders how to treat agent trust as an engineering problem, not a vibe check. The skill defines systematic evaluation pipelines that validate outputs at every execution stage, drawing from production patterns used to vet autonomous recommendations against historical data, budget constraints, and domain rules before anything reaches a user. It contrasts checkpoint verification at defined boundaries with continuous verification that runs assertions in real time while the model generates, so errors do not propagate downstream. pass@k sampling and grader consensus give you a practical way to pick among multiple candidates when quality matters. Install it when you are building agents, skill stacks, or automated workflows where wrong answers are costly, and you need repeatable gates instead of manual re-reads of every run.1installs69View TransitionsView Transitions teaches agents how to wire the React View Transition API so page and state changes cross-fade instead of hard-cutting—closing the perceived gap between web and native apps for solo founders shipping polished SaaS UIs. The skill explains capturing outgoing snapshots, coordinating concurrent rendering, and using addTransitionType so styles can target specific transition classes. Shared-element flows map list thumbnails to detail heroes through view-transition-name, letting the browser interpolate geometry while React keeps updates interruptible. Coverage includes CSS pseudo-elements for fine-grained motion control and practical hooks for Next.js App Router navigations where layout and loading boundaries already exist. Use it when marketing promises a premium feel but default client navigations still flash white between routes. You should have a React 19–capable stack and appetite for progressive enhancement where the API is supported, with sensible fallbacks elsewhere.1installs70Web Asset GenerationWeb Asset Generation is an agent skill for solo and indie builders who need a complete web branding asset pack without hand-resizing icons or hunting platform size tables. From a single source image or brand specification, the agent generates favicons, Apple touch icons, PWA regular and maskable icons, Open Graph and Twitter images, and related splash-oriented sizes modern apps expect. It also writes the companion configuration: HTML link and meta tags for the document head, manifest.json for installable PWA behavior, and social tags aligned with major preview engines. The output is structured for direct insertion into a frontend project, which reduces broken previews on iOS home screens, install prompts, and social shares. Use it while building or refreshing a marketing site, SaaS shell, or content property when you want one automated pass instead of tedious multi-format exports.1installs71Web Design GuidelinesWeb Design Guidelines is an Agent Skills™ package that turns a large, opinionated ruleset into default behavior when your coding agent drafts or audits interfaces. It synthesizes WCAG 2.2 AA expectations, platform human-interface conventions, and empirically common UX patterns into over one hundred concrete checks spanning focus states, form validation, responsive type, reduced-motion preferences, image optimization, navigation hierarchy, dark mode, and internationalization. Solo builders shipping SaaS dashboards, marketing sites, or mobile-friendly web apps can invoke it whenever UI work would otherwise sprawl into inconsistent spacing, invisible focus rings, or contrast failures. The skill is strongest as a guardrail during Build and as a structured review lens before Ship, so accessibility and visual consistency stay embedded in the generation loop rather than bolted on after launch.1installs72Workflow OrchestrationWorkflow Orchestration is an Agent Skills pack skill for builders who outgrow single-shot LLM calls and need dependable multi-step automation. It teaches how to design visual AI flows that combine model steps, data transforms, and external calls—with conditional routes, parallel branches, retry logic, and explicit recovery when a node fails. The Model Context Protocol layer treats each MCP-exposed capability as a reusable graph node, so agents can query databases, touch files, call APIs, or drive browsers within one orchestrated run. Typical solo-builder uses include content pipelines that draft copy, validate claims, generate assets, format for several channels, and queue publication from a single input. The skill emphasizes repeatability and operational clarity over demo magic. It pairs naturally with Claude Code, Cursor, or Codex when you are wiring agent products or internal ops bots. Intermediate complexity reflects graph thinking, failure modes, and integration contracts rather than syntax alone.1installs73Writing PlansWriting Plans is an Agent Skills workflow for solo and indie builders who are about to implement something non-trivial and need more than a bullet list. It takes an approved implementation task and breaks it into a ordered sequence of small steps, each written so an agent can execute it without guessing: concrete paths, complete snippets, and named symbols rather than hand-wavy instructions. After every change step, the plan prescribes how to prove the step worked—a test, curl, or UI check—so mistakes do not stack across later files. The skill fits the stretch between “we know what to build” and “the agent is editing the tree,” which is why it sits on the Build journey shelf under project management even though you can reuse the same pattern during scoped MVP work or structured launch prep. Pair it with your agent of choice in Claude Code, Cursor, or Codex when the diff will span multiple modules and you want reproducible handoffs.1installs