AI Agents: Skills & Distribution

Skills and Knowledge Distribution

• The "skills as markdown" pattern is becoming a standard for AI agent extensibility — Corey Haines' marketingskills repo (17.4K stars) packages 36 marketing skills as .md files consumable by any agent (Claude Code, Codex, Cursor), proving domain knowledge distribution is a documentation problem, not a code problem (from marketing skills ai agents)
• A hierarchical skill architecture with a foundational context file (product-marketing-context) that all other skills reference first ensures every AI marketing task starts grounded in the company's positioning and audience — not generic advice (from marketing skills ai agents)
• Cross-referencing skills bidirectionally (copywriting ↔ page-cro ↔ ab-test-setup) creates an interconnected knowledge graph within the agent, so optimizing a landing page automatically pulls in copy principles and testing methodology (from marketing skills ai agents)
• The .agents/skills/ directory convention (migrated from .claude/) is emerging as a cross-platform standard for agent skill storage, with CLI, plugin marketplace, submodule, and SkillKit competing as distribution layers (from marketing skills ai agents)
• A GitHub-backed plugin marketplace for Claude Teams auto-installs multi-plugin bundles (sub-skills + agents) across every team member's instance and keeps them in sync from a single repo — centralized plugin management with zero manual per-instance intervention (from claude teams github plugin marketplace)
• Codex's plugin model collapses context switching by bringing tools in-app: Chrome and Hyperframe operate as Codex plugins for AI creative workflows; install Slack/Gmail/Computer Use plugins and create custom skills for repeated workflows instead of learning external tools or separate dashboards (from chrome hyperframe codex plugins ai workflow, gpt codex frontend prototype workflow)
• Imagegen-first prototyping: use GPT-5.5's image model to generate visual prototypes, then have the model implement code from those prototypes — annotate slides/docs directly in the Codex app and send visual instructions to the agent (from gpt codex frontend prototype workflow)
• Multi-device always-on agent setup: a Mac mini as always-connected "home base" running 24/7 heartbeat threads (survive device switching), a MacBook as "satellite" for mobile work, the two added as connected devices with mutual SSH so threads continue and files are reachable from either machine (from codex multi device workflow setup)
• The Hermes community is building a cross-platform corpus of real (not theoretical) use cases scraped from X, GitHub, Reddit, Hacker News, YouTube, blogs, and podcasts — community-driven user-story collection becomes a discovery/adoption resource for the agent ecosystem (from hermes agent community use cases)
• Connect Google Workspace (Gmail/Calendar/Drive/Docs/Sheets) first when setting up a personal agent — without it the agent can't effectively manage a workflow; Discord channels can then be wired so the agent processes support tickets each morning and auto-organizes them (from hermes agent integrations superpowers)
• Specialized professional roles like senior design architecture are being packaged as custom agents for Claude, expanding beyond general-purpose assistants into domain-specific professional workflows (from claude senior design architect agent)
• Open source browser automation tools designed specifically for AI agents are emerging as key infrastructure for web interaction and data gathering in agentic workflows (from browser automation agent tooling)
• Cheng Lou's @chenglou/pretext package enables developers to integrate AI into demo creation workflows — installable via npm/bun for immediate use (from pretext ai demo package)
• Index source documents in a raw/ directory then let LLMs incrementally compile a wiki of .md files with summaries, backlinks, and categorized concepts — LLM writes and maintains all wiki data, you rarely touch it directly (from llm powered personal knowledge bases)
• Share abstract "idea files" (gist format) instead of specific code — other people's agents read the idea and customize/build implementations for their specific needs, enabling knowledge distribution without code maintenance burden (from llm personal knowledge base workflow)
• Run LLM health checks over wikis to find inconsistent data, impute missing information with web searchers, and suggest new article candidates — agents that maintain their own knowledge base quality compounds over time (from llm powered personal knowledge bases)
• GStack autoplan skill generates architectural specs for upgraded systems (e.g., git wiki → SQLite GBrain) through single-line prompts, demonstrating agents as system architects not just implementers (from garry tan openclaw git wiki gstack)
• Exo is an open source email client that uses Claude for automated inbox management — described as "Claude Code for your inbox," applying autonomous agent patterns to personal communication (from exo claude email client)
• Single Brain architecture at Single Grain: unified vector DB ingesting all company data every 15 minutes; fleet of specialized agents (Alfred/ops, Arrow/sales, Oracle/SEO, Flash/content, Cyborg/recruiting) with a World Agent coordinator — 50+ daily cron jobs as the nervous system (from shared link without context)
• Agent coordination conflicts are the biggest operational challenge: sales agent promises timelines SEO data contradicts, content agent uses deprioritized keywords, ops agent double-books time slots — required building explicit conflict resolution and security systems (from shared link without context)
• DRI (Directly Responsible Individual) system applied to agent teams: spin up a temporary team around a specific goal, 90-day deadline, agents return to general pool when done, learnings absorbed into World Brain — failures improve the system too (from shared link without context)
• Compounding curve for AI-native orgs: Month 1 terrible (hallucinations, 3am broken automations), Month 2 AutoResearch surfaces patterns humans missed (sales call keywords correlating with 3x close rates), Month 3 flywheel turns as accumulated data improves every agent's output (from shared link without context)
• Months of continuous data ingestion creates a world model competitors need years to replicate — not because the tech is secret but because proprietary data accumulates in ways that can't be fast-forwarded; the data compounding IS the moat (from shared link without context)
• agent-browser (Vercel Labs, 26K+ stars) lets AI agents scrape JavaScript-heavy sites, pages behind logins, and dynamic content using 82% fewer tokens than Playwright MCP — 5-6x more pages per session for knowledge base ingestion (from nick spisak shared link)
• AI agents create decision checkpoints automatically: agent drafts a pricing proposal, human adjusts discount and adds reasoning note — the model's proposal is the structured prior, the human's edit is the judgment signal; tacit knowledge becomes observable (from ashugarg shared link)
• Context amnesia is the fundamental agent problem: a 200K context window changes how much text the model can scan, not how much it "knows" — scanning is not knowing; without a memory system every session IS a first date (from nyk builderz shared link)

Writing and Prose Skills

• The stop-slop GitHub repository (hardikpandya/stop-slop) provides a skill file specifically designed to identify and remove telltale AI writing patterns from prose, addressing the growing need to humanize AI-generated content (from stop slop ai writing pattern removal)
• The project is distributed as a skill file format, enabling integration with AI agent workflows for automated prose refinement (from stop slop ai writing pattern removal)
• Codex Meeting Recorder skill uses GPT Realtime Whisper endpoint for live transcription at $0.017 per minute ($0.51 for 30-minute meetings), allowing questions about transcript content as it's being generated through the Codex interface (from codex realtime meeting transcription gpt whisper)
• Codex displays live transcription in preview pane and generates both full transcript and formatted version upon meeting completion; local realtime option using Nemotron Speech Streaming is being considered as a cost-effective alternative (from codex realtime meeting transcription gpt whisper)
• Use 'impeccable' design skill in Codex for frontend design — outperforms popular uiuxpromax skills; combine imagegen-frontend-web skill with image2 for high-quality design references, then image-to-code skill for 1:1 image-to-webpage conversion (from codex design skills frontend development)
• Use Frontend App Builder skill (built into Codex) for engineering-grade workflows requiring strict image restoration with precise color interpretation and icon alignment; install Build Web Apps plugin for complete design implementation including shadcn/ui components and browser acceptance testing (from codex design skills frontend development)
• Use /grill-me skill in Hermes to systematically uncover project unknowns before starting development, saving all results to memory vault for reference (from hermes agent development workflow)
• Sean Geng's plan-optimizer skill can be installed with one command and uses iterative self-scoring to keep the best plan version each cycle — works particularly well with Fable 5 which can break through previous scoring ceilings (from claude plan optimizer iterative improvement)

Managed Agent Platforms

• Anthropic launched Claude Managed Agents as a Platform-as-a-Service for AI — pairs an agent harness tuned for performance with production infrastructure, taking deployments from prototype to launch in days (from claude managed agents production platform)
• Claude Managed Agents economics: $2.58 fulfillment cost for $1k of service delivery (~99.7% margin potential); 4 user personas determine fit; live console exposes sessions, analytics, and per-agent costs (from claude managed agents breakdown economics)
• The Managed Agents API integrates with Linear's Agents SDK — Claude one-shotted a complete deployment example (linear/claude-managed-agents-demo) for shipping custom agents on a Linear instance (from claude managed agents linear sdk integration)
• Advisor strategy on the Claude Platform: pair Opus as advisor with Sonnet/Haiku as executor to get near-Opus intelligence at a fraction of the cost — splits reasoning from execution as a first-class platform pattern (from claude advisor strategy platform)
• The Monitor tool lets Claude create background scripts that wake the agent only when needed — eliminates polling loops, follows logs for errors, polls PRs via script, and dramatically reduces token consumption (from claude monitor tool background scripts)
• Symphony is an open-source orchestrator that assigns a Codex agent to every open issue in a task tracker — turns issue trackers into always-on agentic systems, shifting humans from doing to reviewing and directing (from symphony codex agent orchestrator)

Self-Improving Skills and Eval Loops

• Self-improving Claude Code skills: define 3-5 binary eval criteria, run the skill 10 times with varied inputs, evaluator scores every output, identifies failure patterns, rewrites the prompt, retests, keeps the winner — a hook-writer skill went 32/50 → 47/50 overnight (from claude code self improving skills automation)
• The improvement loop method works for any creative skill (hooks, briefs, ad copy, scripts, reports) and ends manual prompt tweaking — ideal for DTC brands and agencies whose skills are great 70% of the time and unusable the other 30% (from claude code self improving skills automation)
• /autobrowse skill (inspired by Karpathy's autoresearch): agent explores web pages via the Browserbase CLI, learns from failed attempts, iterates until it converges on a reliable workflow, then graduates the winning approach into a reusable browser skill once token usage is optimized (from autobrowse skill web automation agent)
• ml-intern automates the post-training research loop: reads arXiv papers, walks citation graphs, pulls Hugging Face datasets, launches HF Jobs training when no local GPUs are available, monitors runs, diagnoses failures, retrains — beat Claude Code on GPQA (32% vs 22.99% in <10h) by finding OpenScience+NemoTron-CrossThink and running 12 SFT runs on Qwen3-1.7B (from ml intern automated research agent)
• ml-intern can recognize low-quality data and generate replacements — wrote a script for 1100 synthetic healthcare data points, upsampled 50x, and beat Codex on HealthBench by 60%; full GRPO training with ablation loops runs autonomously (from ml intern automated research agent)

Agent Skill Distribution and Discovery

• FieldTheory CLI (npm install -g fieldtheory, then ft sync) downloads X bookmarks locally so agents can read them; ft viz for visualization, ft classify <url> for tagging — local bookmark graph as agent-readable context, no API limits (from fieldtheory x bookmarks cli tool)
• Allie K. Miller's /ss screenshot skill: Claude lists newest files in your screenshots folder, grabs the most recent (or N most recent with /ss 4), and acts on the trailing argument — /ss huh (explain), /ss fix (debug error or design), /ss do this (reverse-engineer + remix); saves ~1 hour/week (from claude screenshot skill visual processing)
• Browser-tool selection makes a massive difference in agent token usage and latency on the same task — benchmark before adopting; tool choice is now a cost/perf optimization line item, not a default (from browser tools agent cost benchmark)
• Browserbase's open-source catalog of web-agent skills reframes reliable web automation as distributed operational knowledge: researched site playbooks can be reused by any agent instead of rediscovered per project (from browserbase web agent skills catalog)
• Astropad Workbench provides high-performance remote desktop from iPad/iPhone for headless Mac Minis running agents — needed because agents still require human visibility into logs, stuck tasks, and outputs even when "headless" (from astropad workbench headless mac remote desktop)

pm-tooling

• AI PM OS packages this as a 'structure-problem' skill among 243 PM skills (150+ frameworks, 11 workflows), running in Claude Code, Cowork, or Cursor, priced at $499/year for up to 10 PMs, updated biweekly (v2.5), with per-PM product context but shared team workflows/review standards. (from structure problem pm decision skill)

agent-skill-governance

• 'Skills as local files' works well for agents (fast local reads/edits) but breaks enterprise governance: no versioning, no sharing across teams, no ownership, no review — resulting in duplicate, uncanonical skill copies across an org. (from skills as local files governance gap)
• Customer pain quote on ungoverned skills: 'people build a skill and they think it's good. Do they know it's good?' — highlights lack of review/verification process for agent skills in production. (from skills as local files governance gap)
• Runlayer's fix: a promotion pipeline for agent skills — personal → team → department → verified — essentially applying version-control principles (versioning, review, ownership, deprecation) to skills, calling it a reinvention of 20 years of code governance for the agent era. (from skills as local files governance gap)

skills-distribution

• Jason's system converts past Codex sessions into reusable skills and workflows — an applied instance of the 'record and replay' pattern turning demonstrated work into institutional knowledge. (from codex work system jason openai)
• Maker Skills (coreyhaines31/makerskills) packages 19 AI agent skills — spanning decisions, research, second-brain, and content rotation — installable via npx skills add coreyhaines31/makerskills into Claude Code, Codex, Cursor, and other agent tools. (from maker skills for ai agents)
• The repo includes 'meta-skills' — skills whose purpose is to help authors create more skills — extending the 'skills as markdown' distribution pattern (also seen in Haines' marketingskills repo at 17.4K stars) into a self-generating skill-authoring loop. (from maker skills for ai agents)

agent capability growth

• Gumclaw has grown to ~40 skills and ~100 purpose-built scripts, following the rule that any repeated task gets converted into a reusable script or skill — a concrete instance of the 'skills as accumulated tooling' pattern. (from gumclaw gumroad hermes agent operating system)

AI-native operating models

• 'Service-as-a-software': SOPs and client account context are converted from tribal knowledge into version-controlled markdown files in a GitHub repo, so work output is no longer capped by headcount — any team member can run the same logic against any client. (from ai native company os 5 layers)
• Layer 1 (Company OS): SOPs were converted to 50+ Claude skills using research agents that read existing process docs and write markdown, with human review after. Most skills handle ~70% of a task autonomously; a human finishes the last 30%. (from ai native company os 5 layers)

Self-improving systems

• Layer 4 (self-improvement engine): a Pinecone database stores thousands of past LinkedIn posts and outbound campaigns tagged with performance metrics; copywriting skills query it directly so output improves over time, and human edits get fed back in as corrections — this accumulated, tagged dataset is framed as the hardest part of the system for a competitor to copy. (from ai native company os 5 layers)

voice-orchestration

• Practical resource note: this voice-orchestration strategy consumes credits quickly, so use medium-thinking models for spun-up threads and reserve lighter/faster models (referred to as 'luna and terra') when appropriate; also recommend building a 'morning work' skill that scripts how the agent audits projects and proposes next steps. (from chatgpt voice orchestrator workflow)

skills-as-encoded-discipline

• 'linear-methodology' is an agent skill that encodes PM discipline for using Linear: it tracks issues/features, starts new projects, and keeps agent-driven work aligned with the app's intended workflow rather than ad-hoc ticket creation. (from linear methodology agent skill)
• The skill's core mechanism: feed it raw ideas and it decomposes them into a structured hierarchy of milestones, issues, and dependencies inside Linear—turning unstructured input into a project-management-compliant plan automatically. (from linear methodology agent skill)

agent feedback loops

• /human-review opens HTML and Markdown files (or localhost URLs) in a local visual editor where users can edit text directly, resize/move images, and leave comments anchored to specific text or elements, then send all feedback to an AI agent in one batch. (from human review visual editor skill)
• Install via 'Install /human-review globally from https://github.com/petergyang/human-review' pasted into ChatGPT/Claude Code/Codex, or via 'npx -y human-review setup --global'. Usage: '/human-review (your file)' or '/human-review (localhost URL)'. (from human review visual editor skill)
• For HTML files, direct edits and resizes save automatically; for Markdown files and localhost pages, the user must click Send so the agent applies changes to the source—an important behavioral distinction to remember when using the tool. (from human review visual editor skill)

AI slop mitigation

• Author's prior open-source skill /no-ai-slop reached 4K GitHub stars, indicating strong demand for tools that let humans directly intervene in AI-generated content quality rather than relying solely on chat-based correction. (from human review visual editor skill)

skills-and-structure

• Behavior layer via Skills: SOPs are converted into reusable Skills that complete tasks 80%+ of the way autonomously; this team maintains ~20 core skills and 50+ total, organized under a strict root folder structure (CLAUDE.md, /wiki, /clients, /raw-context, /.claude) that requires constant upkeep. (from claude code agent native gtm operations)

AI writing style guides

• Proposed fix for unclear AI-generated technical writing: have agents incorporate git commit message conventions, ASD-STE100 (Simplified Technical English), and Google's developer documentation style guide as explicit constraints. (from ai generated commit messages fix)

agent-alignment-skills

• A skill named 'grill-me' (attributed to Matt) is reported to significantly improve agent alignment with a specific user's thinking patterns/preferences—likely functioning as a probing/clarifying-question skill before agent execution. (from grill me skill alignment)

agent skills for output quality

• Ben Holmes uses five named custom skills/commands to improve LLM output with Opus and GPT-5.6: /grill-me (research), /taste-review (design), /vercel-react-best-practices (React quality), /simplify (remove fluff), /test-app (e2e verification). (from five skills for better llm output)
• Pattern: distinct skills are mapped to distinct failure modes — research rigor, design taste, framework-specific code quality, verbosity, and end-to-end correctness — suggesting a decomposition strategy for skill design rather than one general-purpose prompt. (from five skills for better llm output)

skill extraction from session history

• Set up an autoresearcher to scan through past agent session traces specifically looking for repeated patterns and behaviors, then codify those into reusable skills. (from autoresearcher session trace mining)

pm tooling

• mckinsey-issue-tree is one of 243 PM skills in AI PM OS, a shared operating system running in Claude Code, Cowork, or Cursor, updated biweekly (v2.5), priced at $499/year for up to 10 PMs; each PM keeps individual product context while sharing team workflows and review standards. (from mckinsey issue tree pm skill)

skills-infrastructure-gap

• Buyside teams now have individuals running 5-20 personal AI skills that work well and are used often, but skills remain 'single-player mode'—shared informally via .md file email rather than through any system. (from skills single player mode problem)
• When model providers change guidance (e.g., Claude recommending shrinking skills by 80%), only power users who follow updates on X apply the fix—there's no distribution mechanism to notify the broader team. (from skills single player mode problem)
• Centralizing redundant skills (e.g., avoiding 20 separate review-nda skills) raises unresolved ownership questions: who maintains the canonical version, how do users get updates, and what happens to shared skills when the owner leaves the company? (from skills single player mode problem)
• Missing infrastructure for organizational AI skills: version control, ownership, searchability/discovery, and descriptions. Testing/evals for qualitative knowledge-work skills is currently 'all vibes'—no rigorous method exists yet. (from skills single player mode problem)
• Git is not a viable solution for skill-sharing among average knowledge workers—they will never adopt it, regardless of technical elegance, per Khe Hy's blunt claim. (from skills single player mode problem)
• Proposed solution direction (via @Johnsjawn, tied to Notion demo): a living skills library where skills improve with each use, get discovered instead of rebuilt, and top skills/creators surface via usage-based ranking—organized by team/use-case and usable across any agent. (from skills single player mode problem)

loop-taxonomy

• Encoding manual verification steps as a SKILL.md (e.g. open page, screenshot before/after, check console, fix and rerun) lets Claude self-verify end-to-end and reduces the number of turns needed in turn-based loops. (from anthropic agent loop taxonomy)
• A practical loop-building pattern: use past high-performing content (e.g. 110 newsletter editions) to build a scoring rubric, then have one agent draft, a separate judge agent score against the rubric (avoiding self-grading), and rewrite until a threshold (e.g. 95/100) passes — proprietary engagement data becomes the differentiating 'moat' since all models have read the same public internet. (from anthropic agent loop taxonomy)

agent-skill-diagramming

• Archify is an agent skill installed via 'npx skills add tt-a1i/archify -g' that turns codebases or plain descriptions into typed JSON IR, deterministically compiled into self-contained HTML/SVG diagrams—works with Cursor, Claude Code, Codex CLI, and OpenCode. (from archify agent skill system diagrams)
• Prompt template for generating diagrams: 'Turn [CODEBASE/FEATURE/WORKFLOW] into a [DIAGRAM TYPE] diagram. Choose from Architecture, Workflow, Sequence, Data Flow, or Lifecycle.' Best practice: keep 8-12 core components, one primary path, and push supporting detail into cards rather than adding more edges. (from archify agent skill system diagrams)
• Archify supports interactive verification after generation: search any component and trace its upstream/downstream authored reach, probe exact routes, compare semantic roles, and play guided stories—without inventing topology or claiming runtime impact. (from archify agent skill system diagrams)
• Architecture Delta mode compares two validated Before/After snapshots with a machine receipt showing exact added, removed, changed, moved, and rerouted elements—useful for PR/design review without inferring merge safety or risk. (from archify agent skill system diagrams)
• Output is portable by design: one self-contained HTML file exportable as PNG, SVG, WebM (video), or a 1200×630 share card—no hosted service or WYSIWYG editor required, explicitly excluding Mermaid parsing and general auto-layout from scope. (from archify agent skill system diagrams)

verifiable-agent-output

• Archify enforces atomic validation before delivery: schema, layout, HTML/SVG, route, and label-to-route clearance checks must all pass, or a repair receipt with stable rule codes and supported fixes is returned instead of a raw stack trace—an emerging quality bar for agent-generated artifacts. (from archify agent skill system diagrams)
• Evidence-backed Architecture nodes can mark themselves SRC n and link to Git-verified files/line ranges pinned to a specific public commit, letting diagrams cite exact source evidence on request rather than by default. (from archify agent skill system diagrams)

agent-skills

• The 'show-me' skill (humanlayer/skills) is a markdown SKILL.md file defining a toolbox of visual formats an agent can pick from to explain code: pseudocode, call trees, component trees, file trees, Mermaid sequence diagrams, and diffs. (from show me skill visual code explanation)
• Guidance embedded in the skill instructs the agent to pick the smallest view that makes the key point clear, skip preamble, keep prose brief, and place each visual next to the short text it supports—avoiding overwhelming the user with every format. (from show me skill visual code explanation)
• For changes, the skill favors diffs matched to the topic's shape (component diff, file-layout diff, call-tree diff, control-flow diff) over showing the whole block, unless most of the content is new or ownership/order would otherwise be hidden. (from show me skill visual code explanation)
• When a concept is too dense for Mermaid or involves UI/layout/state comparison, the skill has the agent generate a single focused HTML artifact (diagram, infographic, or slide) matching the product's real styling and data, then opens it via a Bash command. (from show me skill visual code explanation)
• Matt Pocock notes this skill makes PR descriptions 'extremely easy to read,' suggesting skill-driven visual explanation is becoming a practical pattern for code review communication, not just internal agent reasoning. (from show me skill visual code explanation)

agent-usage-audit

• Recommended workflow: feed a new frontier model your full session/project history across multiple agents (Claude, Codex, Hermes) and ask it to surface repeated prompts, manual steps that should become scripts/integrations, repeatable workflows that should become skills, corrections that belong in project instructions, and candidates for cron jobs. (from gpt6 astra first three workflows)

skills as reusable procedure

• Skills files (.claude/skills/*/SKILL.md) encode one procedure each (e.g., cold-email-copy) so repeated prompts produce consistent output instead of drifting each time it's typed differently; Claude loads only relevant skills, keeping context small. (from gtm on claude code agentic outbound)

skill-installation

• Install the official Jev skill for existing projects with: npx skills add typesafe-ai/skills --skill typesafe-ai (from jev pilled typesafe ai skill)

agent-driven-codebase-analysis

• Workflow for adopting a new tool/skill in an existing codebase: install the skill, then prompt your coding agent to analyze the project and identify where/how to apply it—offloading discovery work to the agent rather than manual audit. (from jev pilled typesafe ai skill)