figure description skills package
Standardized accessibility descriptions and verified analysis for electronic, hydraulic, and pneumatic schematics.
Skills for READMEs, API docs, inline comments, changelogs, and technical writing. Keep docs accurate and up-to-date with minimal effort.
147 skills
Standardized accessibility descriptions and verified analysis for electronic, hydraulic, and pneumatic schematics.
Writes conventional commit messages by analyzing your staged git changes. Detects commit type, scope, and breaking changes automatically.
Generates a complete, polished README.md by scanning your actual project structure, dependencies, and code.
Transform raw incident logs and Slack threads into blameless, structured postmortems and 5-Whys RCA reports.
Convert source code into OpenAPI 3.0 specs or Markdown docs via static analysis of Express, FastAPI, and more.
Instantly convert Markdown files into polished, self-contained HTML slideshows with dark mode and navigation.
Writes clear pull request descriptions by analyzing your branch diff. Covers what changed, why, how, and what to test. Works with GitHub, GitLab, and Bitbucket.
Generate role-specific onboarding roadmaps with milestones, resources, and 30-60-90 day plans.
Deep project analysis to generate professional README.md files with API references, scripts, and stack detection.
Design CLI tools with the right flags, help text, and error messages users actually understand.
Automate professional, Conventional Commits-compliant git messages via deep diff analysis.
Transform raw skill documentation into high-conversion, readable marketplace listings without losing LLM context.
Generates user-facing changelogs from git history. Transforms developer commit messages into clear release notes that users actually understand.
Generate comprehensive repository analytics and contributor insights from your git history.
Automatically generate and update a professional CHANGELOG.md from your git history and Conventional Commits.
Generate a README from your actual repo, not a hallucinated guess. Scans your manifests (package.json, pyproject.toml, go.mod, Cargo.toml) for real install steps, scripts, and dependencies across Node, Python, Go, Rust, and Java. Documentation that matches the code instead of drifting from it.
Compare two OpenAPI specs and catch every breaking change before your consumers do — with a client migration table.
Generate structured architectural technical specifications and draft 'lastenboeken' from project descriptions.
Transforms undocumented repositories into professional README files, setup guides, command maps, architecture notes, environment references, testing docs, and AI agent handoff files.
Enforce a 5-phase documentation workflow that verifies code reality against docs using grep and structured templates.
Turn a local Git range, recent commit window, or tag comparison into plain Markdown release notes with tolerant Conventional Commit grouping, breaking-change detection, tagless fallback, and a reviewable SemVer suggestion.
Generate Conventional Commit messages from your staged git diff: auto-detects type and scope from the changed files, flags breaking changes, and keeps work-in-progress out of the message. Clean, searchable history that plays nicely with automated changelog tools.
Stelt een concept-materialenpaspoort en hergebruikinventaris op voor een gebouw of project: materialen, demonteerbaarheid, hergebruikwaarde en oogstkaart bij sloop of renovatie.
Generate a complete pull request description from your staged changes, commits, and branch diff: summary, changes, test plan, and checklist, ready for GitHub, GitLab, or Bitbucket. Cross-checks the file list against what git actually reports, so reviewers get the why and what without hallucinated filenames.
Automatically generate professional, Conventional Commit messages from your git diffs.
From feature idea to 10-section engineering-ready PRD — with anti-goals, success metrics, and open questions.
Draft, update, and convert professional Functional Requirements Specifications (FRS) for procurement and GRC.
Creates structured troubleshooting runbooks for legacy banking systems with incident classification, dependency mapping, log review checklists, escalation paths, rollback guidance, and post-incident summaries.
Convert SOPs and checklists into configuration-ready BMC Remedy Service Request and Work Order design documents.
Produces developer documentation structured around what developers are trying to do — information architecture, quickstart, how-to guides, reference docs, gap audit — for the product described. Use when the user says write developer documentation, create an API quickstart guide, write a README for this library, or audit our docs for gaps. Do not use when the user wants end-user help articles or marketing copy.
Generate an llms.txt for your site and validate an existing one against the spec. The generator turns your sitemap.xml or docs folder into a clean, sectioned llms.txt with one-line descriptions. The validator flags a missing H1 title, a missing summary blockquote, malformed link entries, links with no description, relative URLs that should be absolute, and a referenced llms-full.txt that is not present.
Repo gets views but no stars? Get the one ready-to-paste README fix for the biggest blocker killing your conversion.
Generate beautiful release notes and changelogs automatically from commits, pull requests, and deployments.
Merge files, URLs, and research into a single coherent document with deduplication and source attribution.
Generate a shareable stat card for any repo, with an honest health grade. It reads the file tree and renders a card showing the language mix, file count and size, whether tests, docs, and a license are present, and an A-to-F health grade from a documented rubric. Markdown by default, SVG with a flag. The kind of card people actually post.
Catch documentation that drifted from your code. Flags functions and methods named in your docs that are gone from the source, CLI flags documented but missing from the arg parser, env vars the docs mention but the code never reads, example imports of modules that no longer exist, and npm scripts or Make targets your docs reference but the project does not define. Cross-references your README and docs against Python and JS/TS source.
A repo visitor decides in about ten seconds whether your project solves their problem — and most READMEs spend those ten seconds on installation instructions instead of answering 'what does this actually do'
Professional fine-art documentation assistant for creating collector dossiers, archive records, and gallery previews.
Produces a project handoff document — tacit-knowledge interview, architecture/decision history, gotchas, operational runbook — for someone leaving a project. Use when the user says "write a handoff document", "I'm offboarding, document this project", "knowledge-transfer doc", "onboarding doc for the new developer", or "brain dump before I leave". Do not use for a design proposal — use technical-spec-writer instead.
Turn any git diff into a clean Conventional Commit, a skimmable PR description, and a Changelog entry — one consistent style, every time.
Produces an engineering design doc — problem restatement, proposed design, data-model impact, API changes, failure modes, rollout/rollback plan — for a proposed change. Use when the user says "write a technical spec", "draft an RFC", "design doc for this feature", "architecture proposal", or "engineering spec review". Do not use to document an existing system for a successor — use technical-handoff-writer instead.
Automate publication-ready PR descriptions, release notes, and changelogs from git history and diffs.
Transform technical fragments and code into legally structured patent technical disclosure documents.
Automated daily kickoff and shutdown routine with structured session logging and context recovery.
A two-stage accuracy audit and adversarial review for research-based and factual writing.
Audit Agensi skill packages for marketplace readiness, formatting compliance, and safety pre-checks. Grade a skill package before you publish it: SKILL.md frontmatter, credits math, description routing, missing listing sections, and a light command-and-secret safety pre-check, scored 0 to 100 with plain-English fixes.
Builds a structured architectural map and implementation guide for unfamiliar software repositories.
Enforce document traceability, semantic versioning, and concise house-style rewrites for technical product sets. Part of the Gnosis Technology Product Suite
Checks digital products before upload, including file completeness, folder structure, README quality, licence notes, buyer instructions, previews, thumbnail, ZIP readiness, product copy, pricing notes, platform fit, safety risks, rights risks, and final publishing checklist for creators and digital product sellers.
Turn a user-approved website into a provenance-backed DESIGN.md pack that separates measured tokens, inferred roles, conflicts, and unresolved gaps.
Turns SaaS product updates, feature improvements, bug fixes, workflow upgrades, integration launches, UI changes, and platform enhancements into repeatable release campaigns, including launch notes, user-facing announcements, email copy, social posts, in-app messages, sales enablement snippets, support notes, FAQs, and rollout checklists for founders, product marketers, SaaS teams, and customer success teams.
Comprehensive codebase analysis and implementation tool that reads every file to ensure architectural consistency.
Persistent Markdown graph that tracks project decisions, failed attempts, and open threads across sessions.
Converts rough or incomplete system ideas into structured technical specifications suitable for demos, MVPs, and AI-assisted implementation. Produces a consistent Markdown document covering system inputs, core logic, integrations, outputs, edge cases, and implementation requirements — helping move from concept to code generation faster, without lengthy clarification cycles.
Scans project folder (local or GitHub repo) for source code. Auto-generates/updates per-file docs, a setup guide with dependencies and credentials, and a README with script index. Runs security and health audit - finds hardcoded API keys, tracked credentials, missing .gitignore coverage, broken imports, and TODOs - writes actionable issues.md. Supports three modes: local scan, GitHub URL clone-and-document, and --check freshness report (read-only). Updates the docs iif update is needed.
Compares draft policies against expected policy sections, ownership, responsibilities, control requirements, evidence needs, review cycles, approval routes, training requirements, implementation plans, monitoring expectations, and governance gaps across HR, finance, IT, compliance, risk, operations, data protection, security, and internal control environments.
The meta-skill for AI agents to self-evolve by logging lessons and updating their own instruction files.
Creates troubleshooting guides, recovery flows, failure checklists, alert messages, retry instructions, fallback steps, incident notes, owner actions, documentation templates, and prevention plans for broken Zapier automations, failed Zaps, missing triggers, stopped tasks, API errors, field mapping issues, authentication failures, webhook problems, and business workflow interruptions.
A high-density structured response protocol for radical information compression and mandatory artifact generation.
High-precision fact checking that traces claims to primary sources and assigns provenance-strength grades.
Turn a weighted hiring rubric and redacted CV text into a locator-backed evidence matrix, unresolved-evidence flags, and mandatory human-review queue.
Maps audit requests to internal controls, identifies required supporting evidence, organizes records from approved sources, detects missing, stale, incomplete, or conflicting artifacts, validates period and scope coverage, and prepares review-ready audit packages without modifying authoritative source records. It creates request-to-control mappings, control-to-evidence matrices, PBC trackers, evidence indexes, gap registers, remediation trackers, provenance records, and reviewer-ready packages while preserving traceability, confidentiality, and evidence integrity.
Transforms YouTube videos into SEO-audited, structured blog posts with JSON-LD schema and YAML metadata.
A code-first documentation engineer that audits and writes docs based on implementation, not assumptions.
Turns messy discovery notes into a scoped, tiered, priced client-ready proposal with exclusions, risks, follow-up email, and CRM JSON.
Audit, debug, and fix Claude SKILL.md files to ensure they trigger reliably and follow official templates.
Convert Markdown and plain text into portable, self-contained, professionally styled HTML pages.
Generate, audit, and maintain software documentation end to end.
Generate valid OpenAPI 3.0 specifications directly from PHP routes, controllers, and validation logic.
Translates user stories and acceptance criteria into architecture-consistent, production-ready code.
A multilingual vocabulary engine using cognitive mnemonics, stories, and tech-focused "Geek" modes to anchor memory.
Transform YouTube videos into structured, timestamped Markdown notes with auto-caption error detection.
Builds a structured onboarding pack for any repo: difficulty rating, architecture and domain model, critical flows in learning order, a first safe contribution, tribal-knowledge prompts, and layered AGENTS.md-style context for humans and AI coding agents.
Audits and repairs SKILL.md files to fix broken triggers, YAML errors, and hallucination traps.
Fix environment variable contract drift in a repo using Cursor.
Generate professional, publication-ready README.md files with auto-inferred tech stacks and directory trees.
Standardize AI skill development with production-ready 5-file bundles, automated validation, and token management.
Organize supplied research data-sharing records into a traceable evidence packet with Claude.
Build a searchable technical knowledge system with stack-specific templates and a 60-day implementation roadmap.
Automatically find and fix common security weaknesses in existing projects.
Automatically create accurate API documentation from an existing backend project.
Turns repeated business tasks, team processes, client delivery steps, admin routines, content workflows, sales operations, onboarding actions, support tasks, and internal procedures into clear standard operating procedures with step-by-step instructions, checklists, role responsibilities, screenshot placeholders, QA checks, escalation notes, review cycles, and team-ready documentation.
Organize supplied accessibility feedback into a traceable evidence map with Claude.
A structure-preserving deep reading agent that minimizes information loss and separates source text from AI analysis.
Translates official student accommodation plans into concrete classroom checklists and documentation logs.
Cybersecurity Audit Agent is an evidence-driven AI security auditing skill that analyzes supplied cybersecurity evidence, assesses controls, identifies and prioritizes risks, correlates findings safely, recommends remediation, and verifies corrective actions. It uses a defensible Evidence → Correlate → Prioritize → Assure workflow with strict scope control, prompt-injection resistance, secret protection, framework-aware assessment, transparent uncertainty, and least-privilege operation.
Converts flat ChatGPT prompts into structured, professional agent skill architectures and file systems.
Turn a raw software or AI product idea into a coherent, implementation-ready engineering blueprint with the right requirements, architecture, decisions, risks, and implementation plan.
Turn a messy status update into a doc anyone — human or AI — can scan in ten seconds flat.
Transform standard repositories into AI-native environments with machine-readable documentation and contribution protocols.
Turns business workflows into professional, team-ready SOPs with roles, QA checks, and escalation rules.
A legacy systems specialist that maps unfamiliar codebases using evidence-driven analysis and historical context.
A pedagogical code analysis tool that explains complex logic through layered, level-calibrated teaching.
A documentation engineer persona that writes tested, ruthlessly scoped, and task-oriented developer docs.
Transforms messy tutorial transcripts into structured, source-grounded execution runbooks and checklists.
Turns messy files and transcripts into synchronized, evidence-traced SOPs and training systems.
Generate professional Conventional Commits in Russian from staged Git changes.
Paste any Claude conversation and get a clean, complete PDF transcript — every message, every artifact, automatically formatted.
Use to build and maintain a queryable markdown knowledge base with LLM helpers: canonical entry structure, page links, auto summaries, semantic search and perio
Generate animated, step-by-step data flow diagrams for architectures, code paths, and user journeys.
Turn fuzzy requests into verified implementation specs and ADRs with source-backed architectural gating.
Audit README files for broken links, missing sections, and formatting issues to ensure professional documentation.
Turn your API's route and handler code into a spec-compliant OpenAPI 3.1 document and a ready-to-import request collection — paths, referenced schemas, auth, error responses, examples, and a variable-driven collection with the base URL and token wired up. Derived from your code, not invented.
Turn Markdown tables into a persistent, cross-session Q&A ledger for project tracking and decision logging.
Automates changelog generation, semver suggestions, and release readiness checks from Git commit history — read-only and structured for real release workflows.
Paste any code and get it back with clear, plain-English comments added — line by line. Choose Quick, Full, or Teaching Mode. Works with any programming language.
Audit any AI-generated output for unsupported claims, then verify every factual and technical assertion against its real source before it ships.
5 project type routing, framework decision tree (Spring Boot 3.x/Quarkus), JVM tuning, distributed architecture.
Devs and PMs lose hours hand-building PowerPoint/Google Slides for demos, design reviews, tech talks and stakeholder upd
Align messy Markdown tables so the raw source is actually readable, or build a clean GitHub-Flavored table from pasted CSV. Pads every column to its widest cell, normalizes the header separator row, and preserves your alignment markers (:--, :--:, --:). Changes spacing only, never the cell content. Prints to the screen by default and rewrites the file in place only when you ask.
A fast READY or NEEDS WORK check for your README. Catches the make-or-break gaps — missing what-and-why, setup, or a working example — in about 30 seconds.
Reverse-engineer unfamiliar code. Dependency map, dead code, risk hotspots, onboarding guide. Survive inheriting 200k lines.
Turn git commit history into structured, categorized changelogs with automatic SemVer bump detection.
Write and review the docs AI agents actually read — AGENTS.md for your repo and llms.txt for your site. Drafts them from scratch or audits existing ones for completeness, clarity, and wasted context, with a PASS or REVISE verdict.
Turn a 3am outage into a postmortem in 10 minutes. Slack/PagerDuty ingest, 5-Whys, blameless framing, action items. SEV1/2/3.
Point it at an unfamiliar or inherited repo and quickly understand it. Maps the architecture, identifies the key modules and entry points, traces the core end-to-end flows, surfaces the conventions and gotchas, and assembles a clean ONBOARDING.md — turning a strange codebase into a clear mental model fast. Built for the moment you join a project, take one over, or have to explain a repo before changing it.
Audit and optimize API documentation to reduce friction and accelerate the time to a developer's first successful request.
Generate a spec-compliant llms.txt (and optional llms-full.txt) for your site or repo so AI agents and crawlers can navigate it. Curates the pages that matter, writes the exact llmstxt.org structure — single H1, blockquote summary, and link sections in the precise format agents parse — then validates the format and tells you where to put it. The honest version: a low-cost, machine-readable surface for the agentic web, not an overhyped SEO trick.
Systematic framework for engineering AI agent context at the right level of abstraction
A professional technical editor's review for your docs. Catches missing context, unclear writing, and unverifiable claims in READMEs, API docs, and changelogs before they ship — with a PASS/REVISE verdict and a prioritized fix list.
Turn a diff into a structured pull request description — what changed and why, guidance on where to review and what's risky, honest testing notes, and migration/rollback notes. Scaled to the size of the change, so review is faster and the merge is safer.
Generate consistent API reference docs from your code, OpenAPI spec, or route handlers — per-endpoint parameters, real request and response examples, error codes, auth, and copy-pasteable curl, written for the developer calling the API.
Generate a complete, reader-ready README from your code and project details — not a template dump. It leads with what the project is and why, gives a quickstart that actually runs, and includes only the sections that apply.
Decision-grade web research: tiered sources, real citations, honest limitations. No API keys.
Turn your diffs and commit history into commit messages, PR descriptions, and release notes that reviewers and users actually read. One skill, three jobs — conventional-commit compliant, reviewer-ready, and written in plain language.
Turn timeline fragments, Slack logs, and pager history into a complete blameless postmortem — impact summary, clean timeline, contributing factors instead of a scapegoat, action items with owners and due dates, and lessons that survive the week.
Builders wiring LLM agents to their DB keep discovering the hard way that a chatty tool call can drop rows, exfiltrate P
Extract concrete facts and actionable insights from any text in six customizable summary formats.
Professional grammar and style correction for local files via LanguageTool MCP integration.
Solo builders trying to run 5-10 Claude Code / Codex agents in parallel keep hitting the same wall: worktrees drift, two
Teaches AI coding agents to generate a trustworthy onboarding package for an unfamiliar repository: a verified architecture map, dependency and ownership map, risk register, local development checklis
A technical auditor for SKILL.md packages that validates structure, triggers, security, and marketplace readiness.
Solo AI founders are getting unsolicited 'want to buy your company' emails and freezing — no valuation frame, no reply t
AI coding agents (Claude Code, Cursor, Copilot) ship diffs that quietly add unrequested features, skip acceptance criter
Founders and marketers repeatedly need to source real, quotable customer pain points for a niche or product before they
AI coding agents routinely return a diff that answers a slightly different question than the one asked — extra scope, mi
Outbound threads stall after the first reply — a founder has 30 half-alive conversations and no system for who to nudge,
Builders running Claude Code, Cursor, and API-driven agents watch the monthly bill climb without knowing which sessions,
Builders now generate 3–10 AI drafts per task (code diffs, launch copy, spec variants, prompt versions) and the bottlene