softaworks/agent-toolkit
37 skills119k installs73.2k starsGitHub
Install
npx skills add https://github.com/softaworks/agent-toolkitSkills in this repo
1Mermaid DiagramsMermaid Diagrams is an agent skill that teaches comprehensive Mermaid text syntax so solo and indie builders can produce professional software diagrams without a separate drawing app. It fits anyone shipping with Claude Code, Cursor, or Codex who needs class diagrams for domain modeling, sequence diagrams for API and execution flows, flowcharts for algorithms and user journeys, ERDs for database design, and C4 views for system context. Use it when a stakeholder asks to visualize architecture, when you are writing specs or onboarding docs, or when explaining code structure in chat. Because definitions live in markdown, diagrams stay diffable and updatable next to the repo. The skill emphasizes picking the right diagram type first, then applying consistent syntax so renders do not break silently on bad tokens.4.2kinstalls2HumanizerHumanizer is a Claude Code skill that edits text to remove telltale signs of AI-generated prose, grounded in Wikipedia's maintained "Signs of AI writing" guide from large-scale cleanup experience. Indie builders use it whenever copy must sound credible: launch landing pages, changelog entries, support replies, LinkedIn threads, and documentation that should not scream "template LLM." The skill catalogs twenty-four patterns—such as significance inflation—and shows concrete before-and-after rewrites so agents apply rules consistently rather than vaguely "make it casual." It does not replace fact-checking or brand strategy; it improves diction, rhythm, and specificity. Because writing appears in every phase, treat it as a journey-wide editorial pass you run before publishing anything customer-visible.4kinstalls3Writing Clearly And ConciselyWriting-clearly-and-concisely packages a Strunk-inspired plain English handbook for agents and builders who overwrite or break basic usage. It walks through elementary rules—possessives, serial commas, parenthetics—and composition principles most often violated, without replacing full style manuals. The skill fits whenever text leaves your repo: docs in Build, PR descriptions in Ship review, landing copy in Validate or Launch, and support macros in Grow. Solo makers use it to normalize tone across Claude Code, Cursor, and Codex outputs so stakeholders read one confident voice. It is reference-shaped procedural knowledge rather than a one-shot generator: invoke while drafting or editing any deliverable that humans will read.3.9kinstalls4Qa Test Plannerqa-test-planner is a QA-focused agent skill for solo builders and tiny teams who must ship features with traceable quality evidence without a full QA department. Trigger it explicitly by name—examples include /qa-test-planner or “use the skill qa-test-planner”—then ask for strategy-level test plans with scope and risks, step-by-step manual test cases with expected results, regression suites with smoke paths and execution order, structured bug reports with reproduction steps, or Figma-backed design validation when you supply a design URL. The quick reference table sets expectations on turnaround so you can slot planning into a ship checkpoint before merge or release. Figma MCP support bridges design and frontend implementation, which is especially valuable when one person owns both specs and code. Use it after features are implemented or stubbed, when you need human-executable cases rather than only automated test code, and when stakeholders expect written regression discipline for payments, auth, or checkout flows.3.8kinstalls5Database Schema DesignerDatabase Schema Designer is a checklist-driven agent skill for solo builders who want disciplined relational (and SQL-oriented) data modeling before code and migrations diverge. It walks through pre-design discovery, normalization, table and constraint design, relationships, and related review categories so an agent can audit a proposed schema instead of improvising columns and indexes. It fits indie SaaS and API products where one person owns both application code and the database. Use it in Validate when you lock entities and query shapes, then again in Build while defining migrations, and optionally before Ship when you sanity-check performance assumptions. It is guidance and review structure, not automatic migration generation—pair it with your ORM or SQL migration workflow.3.8kinstalls6Agent Md RefactorAgent MD Refactor is a Claude Code skill from Softaworks’ agent toolkit that reorganizes swollen agent instruction files into a maintainable, token-efficient layout inspired by progressive disclosure (Matt Pocock’s prompt idea). Solo builders accumulate CLAUDE.md, AGENTS.md, and COPILOT.md over months until every session pays the cost of loading hundreds of irrelevant lines, important rules hide in noise, and conflicting guidance goes unnoticed. The skill guides the agent through auditing the root file, keeping only essential universal instructions there, and moving specialized topics into focused linked documents with clear entry points. It is invoked when you explicitly want to refactor, split, or clean up agent config—not for one-off coding tasks. The outcome is faster sessions, easier updates, and a structure new contributors (human or AI) can navigate. It pairs naturally with other agent-tooling skills once the skeleton is lean, and fits indie teams who live inside Claude Code, Cursor, or Copilot with a single repo-level instruction source.3.8kinstalls7Skill JudgeSkill Judge is an evaluation framework skill from Softaworks’ agent toolkit for assessing Agent Skill quality against specifications and community best practices. Most skills fail a simple test: they burn tokens teaching the model what it already knows. Skill Judge encodes the formula that a good skill is compressed expert knowledge with a positive knowledge delta—unique procedures, triggers, checklists, and domain gates—not generic tutorials dressed as SKILL.md. Use it when you are about to publish a skill, auditing a folder you downloaded, or learning how strong skills are structured. It delivers multi-dimensional scores and concrete edits: cut redundant prose, strengthen invoke triggers, align frontmatter, and clarify deliverables. Solo builders curating a personal skill library or submitting to Prism benefit because the agent acts as a reviewer with consistent criteria rather than vague “looks fine” feedback. Pair it after Agent MD Refactor when instructions and skill docs need the same rigor, or before you tag skills for a marketplace listing.3.8kinstalls8Session HandoffSession Handoff is a journey-wide agent skill from the Softaworks toolkit that solves context exhaustion on long solo builds. Before your window fills or you pause mid-feature, it captures decisions, file-level progress, blockers, and explicit next actions in a handoff document a new session can load cold. It triggers when you ask to save state, when the agent detects heavy edit volume, or at milestones like finishing a refactor. Indie builders running multi-day agent sessions on one repo benefit most—whether you are in Build implementing features, Ship fixing review feedback, or Operate iterating on production bugs. It pairs naturally with planning and README skills but does not replace tests or deploy runbooks.3.8kinstalls9Crafting Effective ReadmesCrafting Effective READMEs helps solo builders stop shipping repos with empty or generic docs. It routes you through identifying whether you are creating, adding a section, updating after changes, or reviewing quality, then picks structures suited to OSS libraries, personal experiments, internal tools, or config-heavy repos. Triggers match natural requests like write a README, update the README, or what sections should my README have. Use it during Build when onboarding future-you or contributors, during Validate when a landing-adjacent repo must explain the prototype, and during Launch when GitHub becomes a distribution surface. It is editorial and structural—not a substitute for API reference generators or auto-sync from code.3.8kinstalls10Commit Workcommit-work is a procedural agent skill that turns messy working trees into reviewable git history for solo builders shipping without a dedicated release manager. It forces an inspect-before-stage rhythm: git status, unstaged diffs, and when needed diff --stat to see blast radius. You define commit boundaries up front—separating refactors from features, frontend from backend, and dependency bumps from behavior—then stage with patch mode so one file can land in multiple logical commits. Conventional Commits are mandatory, with optional scope rules you can tighten for monorepos. Before each commit it expects a cached diff review aimed at catching secrets and stray artifacts. Default guidance favors several small commits when changes are unrelated, which keeps bisect and cherry-pick viable for one-person teams. Beginner-friendly if you already use git daily; the skill teaches the sequencing more than new commands.3.8kinstalls11C4 Architecturec4-architecture is an agent skill that turns a messy solo-builder repo into readable C4 architecture documentation using Mermaid diagrams embedded in markdown. You invoke it when someone asks for a system context slide, a container view for onboarding, optional component detail for contributors, or a deployment diagram before production hardening. The workflow is deliberate: clarify which C4 level matches the audience, explore the codebase for real services and data stores, emit the right Mermaid diagram types, and add short prose so diagrams are not orphan images. Context and container views are treated as required baselines; component and deployment layers are added only when they clarify decisions rather than noise. It suits SaaS and API products where you need shareable structure without spinning up a separate modeling tool. Use during validation when scoping what you are building, during build when documenting boundaries for agents and contractors, and during operate when infra topology needs to match code reality.3.8kinstalls12Marp Slidemarp-slide is a Marp presentation styling pack for solo and indie builders who want agent-generated slides to look intentional, not like raw Markdown export. It encodes CSS variables, section padding, heading hierarchy, list spacing, and Japanese-friendly font stacks so Claude Code, Cursor, or Codex can emit deck-ready Marp files in one pass. Use it when you are drafting investor one-pagers during validation, internal architecture reviews during build, launch announcement decks, or grow-phase webinar outlines—all from the same theme. The skill does not run Marp CLI itself; it supplies the design system layer agents merge into slide Markdown. Intermediate complexity: you should know Marp slide breaks (---) and basic CSS overrides. Pair with your content outline or writing skills so structure and visuals stay aligned.3.8kinstalls13Codexcodex is a Claude Code integration skill from Softaworks that lets solo builders delegate heavy code analysis, refactoring, and editing to OpenAI’s Codex CLI without leaving their primary agent session. After you install the skill under ~/.claude/skills/codex and confirm `codex --version`, Claude can spawn `codex exec` or resume an existing Codex session when you ask for a second opinion on architecture, skill quality, or targeted edits. The workflow intentionally asks which model to use unless you name one, and it suppresses stderr thinking tokens by default so Codex reasoning does not bloat Claude’s context—you can still request visible thinking for debugging. This is ideal when you want dual-model leverage on a real git tree during Build, not when you need hosted CI or customer-facing launch copy. Treat credentials and PATH as yours to configure; the skill documents prerequisites but does not install the CLI for you.3.7kinstalls14Professional CommunicationProfessional Communication is an agent skill that teaches solo and indie builders how to write software-team messages that actually get read. It centers on a simple What–Why–How scaffold so emails, Slack-style chats, meeting agendas, and post-meeting summaries stay scannable and actionable. You reach for it when you need to explain a delay to a manager, summarize a sprint for mixed audiences, or translate architecture choices without performative complexity. The overview stresses that credibility comes from being understood, not from showing how much you know. It covers when to use the skill for async comms, stakeholder email, and structured reporting, with keyword hooks for common tools and scenarios. Complexity is beginner-friendly patterns rather than corporate bureaucracy. Pair it with planning or review skills when you must communicate outcomes of technical work, not replace code or MCP integrations.3.7kinstalls15Ship Learn NextShip-Learn-Next Action Planner is an agent skill for solo builders stuck in tutorial paralysis. It takes educational inputs—YouTube transcripts, articles, tutorials, course notes—and outputs structured Ship–Learn–Next cycles: concrete iterations where you ship something small, reflect on what happened, and plan the next rep from real feedback. The stated principle is that repeated shipped reps beat marathon passive study. Activate when you want to implement advice from content, extract steps, or break a big idea into something you can deploy or demo this week. It deliberately avoids traditional study plans in favor of ship plans. Complexity sits at intermediate because you must supply source material and commit to iteration. Use alongside implementation and planning skills once a cycle defines the next build target. It does not replace dependency tooling, automated tests, or launch distribution—you still own execution in your repo and environment.3.7kinstalls16Dependency UpdaterDependency Updater is an agent skill for language-agnostic package maintenance. It scans for ecosystem manifests, detects the project type, applies semver-aware updates—automatic for minor and patch, individualized prompts for major—and respects pinned versions. It also runs security audits, diagnoses why installs fail, and helps resolve conflicts. Solo builders use it when dependencies drift, before a release hardening pass, or when CVE noise shows up in npm, pip, Go, or Rust workflows. The skill reduces manual cross-ecosystem checking while keeping breaking-change risk visible. Expect intermediate complexity: you need a real repo, working package manager, and judgment on major bumps. It complements CI and review skills rather than replacing locked-down renovate bots in large orgs. Quick start phrasing like update my dependencies kicks off auto-detection and the safe update path described in the skill doc.3.7kinstalls17Command CreatorCommand Creator is an agent skill for Claude Code that walks solo builders through turning repeat workflows into slash commands invoked as `/command-name`. It targets developers who want to automate steps, document consistent processes, and scope automation globally or per project. The skill explains what slash commands are, when to invoke Command Creator (new command from scratch, optimizing existing automation), and how structure, instructions, and tool usage affect whether the agent runs the workflow reliably without hand-holding. Bundled guidance covers command patterns, where files should live, usage examples, and best practices so commands behave like mini playbooks rather than one-off prompts. For indie builders shipping with agents daily, this reduces prompt drift and makes delegation to sub-agents or tool-heavy sequences repeatable across sessions and teammates.3.7kinstalls18Reducing EntropyReducing Entropy is a manual agent skill from Softaworks that trains coding agents to treat total repository size as the scoreboard. Unlike default “helpful” refactors that add indirection, it requires you to load a mindset file from the bundled references, state its core principle, and only then propose work that leaves strictly fewer lines than before—or delete the feature entirely. Solo maintainers drowning in half-used modules, duplicate helpers, and “flexible” wrappers use it when a sprint should end smaller, not larger. It spans Build cleanups, Ship review gates, and Operate hardening, but only when you ask for it—it is not a background linter. Agents must count lines before and after and reject churn that increases entropy. It complements planning skills poorly: do not pair with greenfield feature pushes in the same session without a clear deletion budget.3.7kinstalls19GeminiThe Gemini skill is a Claude Code integration that invokes Google’s Gemini CLI so your primary agent can offload work that benefits from Gemini 3 Pro’s large context and strong software-engineering reasoning. Solo builders reach for it when a task spans many files, entire documentation sets, or architectural roadmaps that exceed comfortable single-thread context in the main session. The skill documents purpose (massive windows, advanced coding analysis), explicit activation phrases, and how the wrapper chooses interactive versus automated runs. Typical flows include comprehensive code review, plan critique, and pattern discovery across a monorepo. It complements—not replaces—your default model: you still orchestrate in Claude Code while Gemini handles the heavy panoramic pass. Prerequisites assume Gemini CLI is installed and configured; permissions implications include shell and network for CLI calls.3.7kinstalls20Meme FactoryMeme Factory is an agent skill that lets solo builders produce memes on demand through the free memegen.link API and built-in textual meme patterns. You specify a template and top or bottom copy—or pick greentext and copypasta styles—and the skill returns a PNG URL or formatted text for slack, X, release notes, or internal rituals. It shines when you want lightweight humor during growth content pushes, launch announcements, or even ship-phase morale without Figma. Beginner-friendly: no API key, only network access to memegen.link. It is not a brand system or rights-cleared stock library; template choice and copy remain your responsibility. Pairs naturally with distribution workflows when you need a visual hook fast.3.7kinstalls21Openapi To Typescriptopenapi-to-typescript is an agent skill for solo and indie builders who maintain a backend API described in OpenAPI 3.0 and need matching TypeScript without hand-copying models. After you point it at a JSON or YAML spec, it validates the document version, pulls schemas from components and operations from paths, and writes a single TypeScript module with interfaces, endpoint types, and type guards so fetch clients, BFF layers, and agent tools share one source of truth. Use it when a spec changes and you want fast, repeatable regen instead of drifting manual types. It targets OpenAPI 3.0.x only and defaults output to types/api.ts unless you choose another path. Intermediate complexity: nested schemas and union-heavy APIs still need sane naming in the spec. It is a generator skill suited to Claude Code, Cursor, and similar agents with filesystem access to read the spec and write the output file.3.7kinstalls22Domain Name BrainstormerDomain Name Brainstormer is an agent toolkit skill that automates the tedious loop of inventing memorable names and checking whether they are actually registerable. Solo builders and indie founders use it when starting a company, product, personal site, or rebrand—especially after the exciting first idea hits a taken .com. The workflow analyzes your description and positioning, produces creative candidates, verifies availability across many TLDs, ranks options with short branding notes, and proposes close variants when favorites are unavailable. It saves manual WHOIS hopping and expands naming angles you might not consider alone. Primary placement is Validate scope because a clear, ownable domain locks brand identity before implementation; it also supports Idea discovery and Launch distribution when you need a campaign or microsite name. The skill is generative and research-oriented rather than a registrar integration—you still purchase domains through your preferred provider after picks look viable.3.7kinstalls23Feedback MasteryFeedback Mastery is an agent skill that teaches structured frameworks for hard workplace conversations and constructive feedback. It centers on the Preparation–Delivery–Follow-up model and the Situation–Behavior–Impact technique so you separate facts from interpretation and land clear asks. Solo and indie builders use it when they need to address missed expectations with a contractor, de-escalate tension on a small team, prep a sensitive 1:1, or respond calmly when someone pushes back on your decisions. The skill fits moments where shipping velocity depends on relationships, not only tickets—common in Validate when scoping with a cofounder, in Ship when reviewing quality with a contributor, and in Grow when support and alignment issues appear. It does not replace HR policy or legal advice; it gives repeatable conversation scaffolding so agents can help you draft talking points, anticipate reactions, and plan follow-ups before you speak.3.7kinstalls24Daily Meeting UpdateDaily Meeting Update is an agent skill that helps you produce a polished standup or scrum summary without staring at a blank doc. It first quietly detects what data sources exist—local Git, GitHub, Jira, and Claude Code JSONL history—then offers to pull recent activity before running a structured interview about blockers, today’s focus, and topics for the team. That combination matters for solo and indie builders who juggle agent-assisted coding with async collaborators: the skill captures what tools cannot, while still grounding your update in real shipped work. Use it on busy Build days when you need a consistent format for cofounder syncs, contractor standups, or accelerator check-ins, and again in Operate when incident or maintenance work dominates your diff. Output is Markdown you can paste into Slack, Linear, or a live standup. It is not a replacement for ticket hygiene; it assumes you will answer honestly about impediments even when integrations are missing.3.7kinstalls25Plugin ForgePlugin Forge is an agent skill for building and maintaining Claude Code plugins with correct structure, manifests, and marketplace integration. It walks you through creating a plugin from a name and metadata, generating plugin.json, wiring marketplace.json, adding components such as commands, skills, agents, and hooks, bumping semver consistently, and validating before local test or publish. Indie builders distributing agent capabilities—custom slash commands, bundled skills, or small productized extensions—use it during Build when agent-tooling becomes part of the product surface, not an afterthought. The skill favors automation scripts over hand-editing JSON, which reduces manifest drift between plugin and marketplace files. It assumes you already run Claude Code and have a marketplace root path on disk. It is not a general VS Code extension guide; scope stays Claude Code plugin.json and marketplace.json semantics.3.7kinstalls26Difficult Workplace ConversationsDifficult Workplace Conversations is an agent skill that packages a research-backed Preparation-Delivery-Followup framework for talks that feel risky—missed expectations, interpersonal conflict, promotion or pay, or personal boundaries. Solo and indie builders still face these moments with co-founders, part-time engineers, designers on retainer, and sometimes enterprise clients where tone can make or break the relationship. The skill walks you through clarifying intent and facts before the meeting, choosing language that invites dialogue instead of defensiveness, and closing with concrete next steps and follow-up cadence. It is procedural knowledge for humans in the loop: your agent helps you draft talking points, anticipate objections, and plan recovery if the room heats up. Use it when anxiety or avoidance is delaying a necessary conversation, not as a substitute for legal HR counsel on termination or discrimination. Optimized for builders who ship fast but cannot afford silent resentment on a five-person team.3.7kinstalls27React DevReact-dev is an agent skill for solo builders shipping typed UIs with React 18 and 19. It steers implementation toward compile-time guarantees: generic components, correctly typed events and refs, custom hooks, and router integration with TanStack Router or React Router. When React 19, Server Components, Actions, or useActionState come up, the skill anchors migration details such as ref-as-prop instead of forwardRef and useActionState replacing older form-state hooks. Use it while you are actively building or extending frontend surfaces in a TypeScript React repo; skip it for backend-only work or JavaScript-only React where types are out of scope. The outcome is components and hooks that agents and humans can refactor without silent runtime breakage.3.6kinstalls28React Useeffectreact-useeffect is a procedural React skill that trains solo builders and their agents to replace unnecessary useEffect with clearer patterns: compute derived state in render, memoize only when profiling shows real cost, and use key to remount when identity changes. It fits indie SaaS and marketing sites where agents often mirror props into state or fetch-on-mount when a render-time calculation or keyed subtree would be simpler and fewer bugs. Use it during Build frontend work and again in Ship review or Operate iterate when performance or stale-state issues trace back to effects. The guidance is opinionated in the modern React direction—fewer effects, intentional renders—without requiring a specific framework beyond React hooks.3.6kinstalls29Game Changing FeaturesGame Changing Features (10x Mode) is an agent skill for solo and indie builders who want strategic product thinking instead of incremental feature lists. Trigger it when you ask what would make the product ten times more valuable, what to build next, or when you mention 10x or product strategy. The workflow forces understanding of current value—who uses the product, what problem it solves, and the core user action—before proposing game-changing moves under optional constraints like team size or timeline. Responses must land in structured session files, not casual chat, which makes outcomes citable for later planning skills or your own roadmap doc. It spans Validate scope work and early Idea research when you are still choosing direction, and it pairs with Build PM moments when reprioritizing. This is pure strategy: no code generation in-session.3.6kinstalls30Naming AnalyzerNaming Analyzer is an agent skill from the Softaworks toolkit that acts as a dedicated naming reviewer for solo builders who want readable code without scheduling a human pass on every PR. It inspects variables, functions, classes, and related identifiers to surface vague labels, misleading names that disagree with behavior, unclear abbreviations, and boolean prefixes that do not signal intent. The workflow is framed around an analysis phase that can scale from a single file to a directory or entire repository, then returns actionable rename suggestions aligned with common language conventions. That makes it useful both while you are still implementing features and right before you ship, when small naming debt compounds into onboarding friction. Trigger it with natural requests such as analyzing naming in a path, checking conventions, or helping rename functions after a behavior change. It complements general linters by focusing on semantics and maintainability rather than formatting alone.3.6kinstalls31Lesson LearnedLesson Learned is an agent skill that mines your real git history—not generic advice—and turns the last burst of implementation into structured engineering reflection. Solo and indie builders who move fast often skip debriefs; this skill pauses on the commits you just made, interprets structural choices and trade-offs in the diff, and names the underlying software-engineering principle in plain language. It fits after you merge a feature, close a gnarly debug loop, or finish a refactor when you want growth without a formal retrospective. Output stays anchored to your repository: each takeaway cites how the principle showed up in your code, why it matters for maintainability or velocity, and one concrete thing to try next time. It complements code review and planning skills by closing the loop on learning from execution rather than from specs alone.2.7kinstalls32GepettoGepetto is a planning orchestration skill for solo builders who have a markdown spec—detailed or vague—and want implementation planning treated as a formal pipeline rather than one-shot chat. It forces an opening banner, validates that invocation includes a `.md` spec (inferring the planning directory from that file’s folder), then walks through research, stakeholder-style interviews, spec synthesis, plan drafting, external multi-model review, and final sectional breakdown. Indie developers wearing PM and architect hats use it when a feature touches multiple concerns and they want artifacts on disk for the coding agent to follow. It is heavier than lightweight plan snippets: expect numerous markdown outputs and deliberate stops when inputs are wrong. Approved sectional plans are meant to hand off to implementation skills or human execution without re-deriving requirements mid-build.1.3kinstalls33Requirements ClarityRequirements Clarity is an agent skill for solo builders facing hand-wavy feature requests from stakeholders—or from their own backlog—before anyone writes code. It intervenes when requests lack technology choices, integration points, performance or security constraints, acceptance criteria, success metrics, edge cases, or clear in/out scope. Through systematic, one-category-at-a-time dialogue, it applies YAGNI via 'Why?' and KISS via 'Simpler?' to collapse oversized ideas into an MVP-shaped PRD you can hand to an implementation agent. A 100-point scoring system gives you a shared bar for 'ready to build' instead of vibes. The skill deliberately does not fire on pinpoint bug work with file paths, embedded code, or referenced functions—those are already concrete. It shines on multi-day efforts and cross-cutting capabilities where misunderstanding costs a week. Primary home is Validate scoping, but invoke again at Build kickoff whenever a new epic arrives without criteria.562installs34JiraThe Jira skill wires your coding agent into Atlassian issue tracking without forcing one integration style. On every request it detects whether the jira CLI is on PATH, whether mcp__atlassian__* tools exist, or whether the user still needs setup—then routes to the matching reference. Solo builders use it to pull ticket context into the editor, create bugs or stories from conversation, transition states, assign work to themselves, and skim sprint/backlog status when keywords or issue keys appear. It is aimed at indie teams already living in Jira Cloud rather than replacing a full PM methodology. Expect shell invocation for the CLI path and MCP tool calls for the Atlassian server path; neither path invents credentials. Pair it with your normal branch workflow so agent actions stay mirrored in the board the rest of the team sees.538installs35Draw Iodraw-io is an agent skill for solo builders who need publication-ready architecture diagrams, flowcharts, and technical visuals without switching to a separate design toolchain. It treats `.drawio` files as editable XML so an agent can adjust positions, margins, and element structure programmatically instead of only describing changes in chat. Use it when you are documenting system design, onboarding teammates, or preparing Quarto or presentation assets and want PNG exports that stay visually consistent. The workflow covers direct XML manipulation, automated PNG conversion, font family enforcement across the graph model, AWS icon integration, and layout calculations that reduce overlapping nodes. It fits indie SaaS and API projects where clear diagrams speed validation conversations and reduce rework in READMEs, ADRs, and slide decks. Intermediate complexity: you should understand basic diagram semantics and be willing to run conversion scripts or pre-commit hooks when exporting assets.527installs36Backend To Frontend Handoff DocsBackend to Frontend Handoff Docs is an agent skill that turns finished API work into a structured markdown handoff frontend developers—or their AI—can implement against without reopening backend threads. Trigger it when backend endpoints, DTOs, validation, and business logic are complete and you say create handoff, document API, or frontend handoff. The skill enforces a quiet mode: no discussion in chat, only the document saved to the handoff file. For complex features it captures feature name, user flows, constraints, gotchas, and technical contracts; for straightforward CRUD it allows a minimal endpoint-plus-example-json shortcut. Solo builders shipping full-stack alone still benefit because it forces explicit contracts before UI work and reduces integration bugs. It assumes you already have the API code in the repo from the same session or branch.510installs37Frontend To Backend RequirementsFrontend-to-backend-requirements is a Claude Code skill for solo builders and tiny teams where one person wears the frontend hat and another (or future you) owns the API. Instead of dumping OpenAPI fantasies from the client, it walks you through documenting the screen purpose, the information the UI must show, permissible user actions and outcomes, and every state the interface must handle—including loading, empty, and failure paths. It explicitly captures open questions and assumptions so backend can propose shapes and endpoints. The output reads as requirements engineering for full-stack products: enough for Validate and early Build planning without locking implementation. Use when you are designing a new feature pane, listing what a component needs from the server, or when someone asks what the backend should provide for a flow you are mocking in the frontend.506installs