Agents are good at writing code but have no built-in way to produce real CAD files. text-to-cad adds that. The agent describes a part in code, and the project turns it into standard 3D formats you can open in other CAD or slicing tools.

It is built on a Python package called cadgen, which uses build123d and the Open CASCADE geometry kernel. It runs through uv, so the first start downloads the runtime. A local server lets the agent show models in a viewer, either as a card in the chat or as a link that opens in your browser.

It ships as a plugin for agents that support plugins, and as plain skills through the Skills CLI for agents that don't. It sends anonymous usage stats and crash reports by default. The README explains how to turn that off.

Read more on interesting repos · GitHub

AI coding agents are good generalists, but they often lack step-by-step know-how for specific jobs such as a security audit, an SEO review or a board meeting prep. This repo supplies that know-how as skills. Each skill is a folder with a SKILL.md file of instructions, small Python scripts, and reference documents like templates and checklists.

The README separates three ideas. Skills describe how to do a task. Agents decide what task to run. Personas set who is doing the thinking, such as a startup CTO or a CFO. You can combine them. The Python tools use only the standard library, so there is nothing extra to pip install.

Most of the content follows the shared SKILL.md format, so one repo covers many tools. It installs directly as Claude Code plugins, Codex skills and Gemini CLI skills. A convert script produces formats for Cursor, Aider, Windsurf, Kilo Code, OpenCode, Augment and others. Note that the README's counts of skills and tools vary from section to section, so treat the numbers as approximate.

Read more on interesting repos · GitHub

Claude Code can be extended with agents, slash commands, hooks, MCP servers and skills, but you have to find or write each one yourself. This project gathers a large collection in one place. You install pieces by name from the command line, or browse them at aitmpl.com.

You run npx claude-code-templates with flags such as --agent, --command, --hook, --mcp, --setting or --skill, and it adds the chosen component to your Claude Code setup. With no flags it opens an interactive browser. Many components come from other open-source collections, which the README credits and says keep their original licenses.

Beyond the catalog there are helper tools: an analytics view of your sessions, a mobile-friendly chat monitor with optional Cloudflare Tunnel access, a health check for your installation, and a plugin dashboard.

Read more on interesting repos · GitHub

AI coding agents often write working code that ignores framework-specific performance and design habits. This repo packages that knowledge as skills: folders holding a SKILL.md with instructions, plus optional scripts and reference docs. They follow the open Agent Skills format.

Once installed, the agent picks a skill when your task matches it. Ask it to review a React component and it can apply the React best-practices rules. Ask it to deploy and it can package your project and upload it to Vercel. The README lists eight skills, including vercel-optimize, react-best-practices, web-design-guidelines, writing-guidelines, react-native-guidelines, react-view-transitions, composition-patterns and vercel-deploy-claimable.

Unlike a general style guide, the rules are ranked by impact in places, such as critical for removing request waterfalls and cutting bundle size. The vercel-optimize skill collects Vercel metrics first, then looks only at the routes and files those metrics point to.

Read more on interesting repos · GitHub

Lark (called Feishu in China) is a workplace suite with chat, documents, spreadsheets, calendar, mail and more. lark-cli lets you use those from a terminal, and lets an AI agent do the same, instead of clicking through the app or writing raw API calls.

Commands come in three layers. Shortcuts start with a plus sign, such as +agenda, and have smart defaults, table output and dry-run previews. API commands map one to one onto platform endpoints. Raw API calls reach anything else on the Lark Open Platform.

It also ships agent skills, which are instruction files an AI tool loads so it knows how to use each part of Lark. Login can act as you or as a bot, and credentials are kept in the operating system keychain. Companies embedding it in their own agent can use the extension packages for central credentials and audit logging.

Read more on interesting repos · GitHub

AI-written text tends to share habits: "it's not just X, it's Y" lines, one-sentence dramatic closers, forced triads, decorative bold and headings, and leftover chatbot phrases like "I hope this helps!". Readers notice these quickly. Humanizer is a skill you install in an AI agent that spots these habits and rewrites around them.

Its pattern list comes from Wikipedia's "Signs of AI writing" guide. It marks every tell it finds, strongest first, drafts a rewrite, critiques that draft, then gives a final version. It is told not to invent facts: names, numbers, dates and quotes must come from your source, and if a detail is missing it asks you.

You can paste text, point it at a file, or add a sample of your own writing so the result matches your voice. The README says it edits for human readers and is not meant to beat AI detectors, which still flag most of its output.

Read more on interesting repos · GitHub

Agent Skills are folders that bundle instructions, scripts and resources so an AI agent can do a specific task the same way each time. This repository collected skills for OpenAI's Codex and follows the Agent Skills open standard.

Skills live in three folders. System skills install automatically with recent Codex. Curated and experimental skills are installed from inside Codex with the $skill-installer command, by name, by folder, or by GitHub directory URL. You restart Codex afterward so it picks up the new skills.

The README says this repository is deprecated. It points to the OpenAI Plugins repository for current skill and plugin examples, and to a Build plugins guide that covers making a skill-only plugin.

Read more on interesting repos · GitHub

Claude Code can load skills: packaged instructions it follows when you call a slash command. This repo from HumanLayer bundles six of them, and you install only the ones you want.

Some skills help with everyday work. show-me explains a topic with diagrams, code sketches and small HTML pages. visual-pr opens or updates a pull request with a visual outline for reviewers. narrow-react-prop-types tightens React prop types to match code paths that run in the real app, not ones that exist only in Storybook, tests or mocks.

Others help you set up agents. improve-claude-md rewrites your CLAUDE.md using <important if> blocks, aiming to make Claude follow instructions better. build-iterated-agentic-loop and design-control-loop create a repo-local skill and a scheduled coding-agent GitHub Actions workflow. design-control-loop first interviews you about your codebase. The README is brief, so check each skill's files for details.

Read more on interesting repos · GitHub

The author has led dev teams for over twenty years without writing code. Agents kept failing in the same ways: building the wrong thing, giving one model's opinion on a hard decision, writing prose that sounds like AI, and losing context when a session ran long. Each skill is a written-down fix for one of those patterns.

A skill is a plain-markdown SKILL.md file the agent reads on its own. Fifteen are adapted from Matt Pocock's Skills For Real Engineers, three from Lauren Tan's pstack, and five are original. The author rewrote them for someone who won't read the code, then tied them to one orchestrator session. That session takes your idea and decides what gets questioned, mapped, prototyped, built and reviewed.

The repo ships two editions: original Claude Code plugins, and a Codex desktop plugin adapted for Astra workflows. Any runtime that can read markdown can use the skills if you copy or symlink them in.

Read more on interesting repos · GitHub

AI agents can call almost any Python package, but they often miss the conventions of a scientific field: which endpoint to query, how to page through results, what checks to run before trusting an output. This repo supplies that know-how as skills. A skill is a folder with a SKILL.md file that an agent reads when a task matches.

The skills fall into a few groups. More than 70 cover Python packages such as RDKit, Scanpy, scikit-learn, pymatgen and Qiskit. A Database Lookup skill covers 80 databases, including PubChem, ChEMBL, UniProt and ClinicalTrials.gov. A few integrate with lab platforms like Benchling and Opentrons. Others handle literature review, scientific writing, peer review, and slides or posters. Some skills also ship scripts, templates and tests.

It follows the open Agent Skills standard, so it works with Cursor, Claude Code, Codex, Google Antigravity and other compatible hosts. It is also packaged as an Agent Plugins bundle. The README says the agent can still use any package on its own; these skills add curated, version-aware guidance for the ones listed. Clinical and animal-welfare skills are described as research aids, not decision tools.

Read more on interesting repos · GitHub

AI coding agents often write dated Go. The README gives two reasons: models don't know features added after their training cutoff, and older patterns appear more often in training data, so they get picked even when the model knows the newer one.

This repository fixes that with an explicit reference. The agent reads your project's go.mod to find the Go version, then uses language features and standard library additions up to that version. For example, it uses max(a, b) instead of an if-else block, slices.Contains instead of a hand-written loop, and cmp.Or instead of a chain of checks.

It shares its goal with the Go team's modernize analyzer, which updates existing code. These guidelines aim at new code, so agents write modern Go from the start. It ships for Junie, Claude Code, Codex and Cursor, and for other agents through skills.sh.

Read more on interesting repos · GitHub

AI coding assistants forget everything between sessions. You correct the same mistake twice, or the assistant re-learns through trial and error something it already worked out last week. Hindsight is a single skill file that targets this problem.

When you ask for it, it goes back over the whole session: the tasks, the corrections and the dead ends. For anything that took several tries, it looks for the one upstream fix that would have prevented the chain. It keeps only lessons that would change how future work is handled and writes them to the assistant's memory folder. A clean session gets a plain 'nothing to report'.

It was built for and tested with Claude Code's per-project memory. Before writing, it checks whether an existing memory already covers the topic and extends that one instead of adding a near-duplicate. It never redoes the session's work and runs only when you trigger it. Per the README, it falls back to a written report if there is no memory system.

Read more on interesting repos · GitHub

Agents often need data from services like SEO tools, people enrichment or scraping APIs. Those usually mean a subscription, a signup, or no public API at all. Treg holds the provider accounts and bills small per-call fees from a prepaid balance. The README compares it to OpenRouter, but for tools instead of models.

It works as a proxy. You send the real upstream request through treg with your token. Treg finds the tool, adds the credential on the server, and relays the response. Callers never hold the keys. Your own key for a provider always beats treg's, and those calls are not metered.

Teams can also register their own endpoints, vendor CLIs such as stripe or gh, and SKILL.md recipes, so teammates' agents can run them through treg. Treg does not pick a provider for you or fail over silently, except for routed endpoints you opt into. It is built by the Superdesign team, hosted at treg.to, and can be self-hosted.

Read more on interesting repos · GitHub

Claude Code and Claude Cowork can be extended with plugins. This repo is the catalog of plugins written by people outside Anthropic. The catalog is one file, .claude-plugin/marketplace.json, which Claude Code reads to know what it can install.

The repo is a read-only mirror, synced nightly from Anthropic's internal review pipeline. Authors submit plugins through a web form on claude.ai, and each one goes through automated security scanning and approval before it is listed. Pull requests opened against the repo are closed automatically.

It sits next to two related catalogs: anthropics/claude-plugins-official for plugins Anthropic maintains, and anthropics/knowledge-work-plugins for role-specific plugins. This one is for community contributions.

Read more on interesting repos · GitHub

Patients and caregivers often face piles of documents, unfamiliar terms and scattered advice. The author built this skill after hearing from many people supporting a loved one through cancer. It aims to answer three questions: what to do next, what is known, and how to advocate for yourself.

You install it into an agent such as Claude Code or ChatGPT, then give it context: a brain dump, a pasted report or a new test result. It writes a brief with patient information, up to three next actions, what is confirmed versus unclear, plain-English medical terms and a compact care log. You can save it as a local Markdown file or a shareable Google Doc, and update it over time.

Its research is tied to named sources: NCI PDQ summaries, national drug regulators, official clinical guidelines, PubMed and the ClinicalTrials.gov API. A bundled Python script searches trials, filters sites by distance from home and labels each site's recruitment status. The README states clearly that it does not diagnose, choose treatment, decide trial eligibility or replace the medical team.

Read more on interesting repos · GitHub

Most AI advice sounds sure of itself before it knows your situation. This skill tries to fix that. When you give it a decision, it checks whether it has enough context. If not, it interviews you instead of guessing.

Once it has enough, it applies five separate lenses to the same facts: Product Clarity, Risk and Capital, Scale and Systems, Offer Strength, and Future Self. The first four are inspired by public principles linked to Jobs, Buffett, Bezos and Hormozi. The README says they are analytical lenses, not simulations of those people. The workflow is called CRIT: Context, Role, Interview, Task.

The output is structured: a context read, the five views, where they disagree, a future-self check, and a final brief. It is a prompt, not software. The README says it reorganizes the context you give it and does not prove market demand.

Read more on interesting repos · GitHub

Models tend to write in narrative order: background, findings, then the point. That buries the one line a busy reader needs. This skill flips the order to the one consultants are taught: the answer, then the reasons, then the evidence under each reason.

It is one SKILL.md file with no dependencies. It defines five operations: restructure, buried-lede test, reason audit, so-what pass, and email version. It applies Minto's grouping rules to the middle layer and tells the model not to invent facts while tightening. The README notes Minto's rules do not require exactly three reasons, so the skill does not force that number.

It is deliberately restrained. When it loads on a draft you shared, it says what it noticed and asks before rewriting. It leaves incident timelines, runbooks, tutorials and thank-you notes alone. The README says this holds on Opus, Sonnet, GPT-5 and Gemini but not on Haiku, so use a stronger model or check the output.

Read more on interesting repos · GitHub

AI agents need a reliable way to call the apps people already use. Zapier Connectors packages each app as one folder of scripts, plus a SKILL.md and reference notes that an agent can read. The catalog targets the 9k+ apps Zapier integrates with.

Each connector fits two standards at once: an agentskills.io skill and an MCP Tool-shaped TypeScript module. You can install it as a skill in clients like Cursor, Claude Code, Codex or Copilot. You can also import it in Node code, run it as a CLI that reads JSON on stdin, or start it as a local MCP server.

Zapier is the easy path for auth, but not required. Each connector can instead read your own token from an environment variable. The README marks the project as a prototype: pre-1.0, breaking changes in minor versions, and nothing is a stable contract yet. The license is Elastic License 2.0.

Read more on interesting repos · GitHub

AI tools can leave provenance marks in what they produce. Some are invisible Unicode characters in text. Some are metadata inside images, PDFs or Office files, such as C2PA manifests, EXIF and XMP. Others are statistical patterns in word choice. This project aims to clean these from content you own, for privacy and hygiene.

It has two parts. The skill is markdown only and acts as a thin client. The service is a Python 3.10+ standard-library HTTP server (default http://127.0.0.1:8765), so the agent host needs no Python. Layer A uses deterministic scripts to remove invisible characters, odd spaces, bidi controls and tag characters. Layer B targets statistical text watermarks by having the agent rewrite the text, with an optional rewrite hook that can use a local Ollama model.

A skill is only an instruction the model may ignore, so the Claude Code plugin also adds a PostToolUse hook. The harness runs it on every file the agent writes, and it either reports marks or cleans them in place. The README says no hook can change chat messages, so text that exists only in chat still relies on the best-effort skill workflow.

Read more on interesting repos · GitHub

AI agents often write prose with recognizable habits. Sloptrim checks for those habits each time an agent saves a text file and gives the file a score from 0 to 100. If the score is high enough, it asks the agent to rewrite the flagged parts.

It works with plain rules, not a model. A Python script reads the text, applies detectors for 62 of its 71 documented patterns, and reports matches and metrics as JSON. Of those 62, 50 can change the score. The other 12 are shown as writing advice only. The remaining 9 patterns have no detector and are handled by the agent during the rewrite. It reads 20 formats, including .docx, .pptx and .epub, and it looks only at prose, never code.

The README is frank about the limits. It is not an authorship classifier and cannot prove a model wrote something. On a public benchmark its ranking ability (ROC-AUC) ran from 0.762 to 0.946 depending on the model, and at the default threshold it catches only some samples. It also cannot see files written through a Bash command.

Read more on interesting repos · GitHub

Coding agents often wrap a simple answer in praise, background, side notes and an offer to help more. The useful instruction ends up in the middle of a paragraph. This skill gives the agent ten rules so the answer comes first and the rest stays out of the way.

It is a skill/plugin file (SKILL.md) that the agent reads and follows. The README shows a before and after: a long paragraph about an auth bug becomes one command, three numbered steps and one line saying what to do if a test fails.

The rules are plain text, so you can change them. Fork the repo, edit SKILL.md, and install your copy in place of the original. The README says it is loosely based on a book about adult ADHD, adapted for how an LLM should respond, and that no diagnosis is needed to use it.

Read more on interesting repos · GitHub

You buy a technical book, read it once, and months later can't recall what was in chapter 7. Searching a PDF gives you page lists, and asking an agent about the book either produces made-up answers or an admission it lacks the content. book-to-skill converts the book into a skill your agent can read on demand.

It works in two halves. A Python extractor turns the document (PDF, EPUB, DOCX, Markdown, HTML, RTF, MOBI and others) into clean text and metadata. Then your agent follows the project's SKILL.md spec to write the skill: a core file of mental models with a chapter index, one file per chapter, plus a glossary, a patterns file and a cheatsheet. Only the chapter you ask about gets loaded.

The obvious alternative is dumping the whole book into the prompt. The README claims 24x to 51x fewer tokens per question than that, measured on real books, and links to its methodology. The same approach works on internal docs, brand guidelines, papers and specs. The output follows the open Agent Skills format, so Copilot CLI, Amp, Claude Code, Hermes Agent, OpenCode and OpenClaw can read it.

Read more on interesting repos · GitHub

Drawing system diagrams by hand is slow, and static images go stale or hide detail. Archify is a skill you install into an AI coding agent. You describe a system in plain words, or ask the agent to read a repository, and it produces a diagram.

The result is one standalone HTML file. Open it in a browser to click nodes for details, trace a path between two points, or follow everything upstream or downstream of a step. You can keep refining it by chatting with the agent, for example asking it to add authentication or switch to the light theme.

The repo tags itself as a Mermaid alternative. The README says diagrams from code are traced against the source and checked, and that the typed JSON sources and validation receipts are in the repo. Because the output is plain HTML, people have also edited it into small tools, such as a travel itinerary.

Read more on interesting repos · GitHub

AI models trained on similar SaaS templates tend to produce the same frontend look: Inter for every font, purple-to-blue gradients, cards nested in cards, gray text on colored backgrounds. Impeccable gives your coding agent explicit design guidance so it avoids these habits.

It installs as a single skill called /impeccable. You run /impeccable init once, and it inspects your project and writes a PRODUCT.md file with lasting facts about your audience, purpose and constraints. After that, you run commands like /impeccable audit or /impeccable polish on a page or component, and the agent follows the guidance.

It started from Anthropic's frontend-design skill for Claude and extends it with a shared command vocabulary and a detector. The CLI and browser extension run 61 deterministic rules without an LLM or API key. Other checks are done by the LLM as part of critique.

Read more on interesting repos · GitHub

AI agents often need to produce Office documents, but the usual route is a Python library such as python-pptx and many lines of code per slide. OfficeCLI replaces that with short shell commands, for example adding a slide with one `officecli add` call. It is written in C#, ships as one binary, and needs no Office install.

Every element in a document has a path, such as /slide[1]/shape[1]. You work on those paths with commands like create, add, set, get, remove and view, and you can get plain text or JSON back. A live preview (`officecli watch`) opens in your browser and refreshes after each command.

The README says its built-in renderer turns documents into HTML or PNG, so an agent can render, look at the result and fix it. An install command also adds a skill file to coding agents it detects, including Claude Code, Cursor, Windsurf and GitHub Copilot. For people who prefer a desktop app, the README points to AionUi, which is built on it.

Read more on interesting repos · GitHub

AI coding tools tend to produce the same safe-looking landing pages, because they fall back on the most common design patterns they were trained on. Hallmark is a set of instructions (a skill) that you install into your coding tool to steer it away from those defaults.

For a new brief, it chooses a macrostructure (the overall shape of the page), dresses it in one of twenty-one themes, and runs fifty-seven checks plus a self-critique before handing the page back. If no theme fits, a Custom mode designs the palette, type and layout from scratch. The output is self-contained HTML and CSS.

The README says two pages from different briefs should feel like different sites rather than colour swaps of one template. Beyond building, it can audit existing code, redesign a page, and study a screenshot or URL for its design traits.

Read more on interesting repos · GitHub

Solo founders do many small jobs by hand: weighing decisions, researching topics, keeping notes, planning posts, watching cash. This repo packages those jobs as skills, which are markdown workflow documents (SKILL.md files) that an AI coding agent can load when you ask for them.

Each skill takes structured input and produces structured output saved to your own files. For example, decide asks about your choice, picks questions from the 37signals decision framework, and archives the answer with a revisit date. You can run a skill with a slash command, or read the SKILL.md and follow the steps yourself.

Skills call one another by name instead of repeating work. The repo is generic and public, while your personal data and config live in a separate local folder that is not committed. It also includes meta-skills for writing your own skills, wiring up integrations, and setting up scheduled loops.

Read more on interesting repos · GitHub

If you work in Claude Code but also have access to OpenAI's Codex, switching between the two is clumsy. This plugin adds slash commands to Claude Code so you can ask Codex to review your changes or take on a task, then read the results in the same place.

It does not bring its own runtime. It talks to the Codex CLI and Codex app server already installed on your machine, so it uses your existing Codex login, config file, and repository checkout. Long jobs can run in the background, and you can check on them or cancel them with other commands.

There are two kinds of review. The normal review is read-only and matches what /review does inside Codex. The adversarial review accepts extra focus text and challenges design choices and risks. An optional review gate can also run a Codex review before Claude stops, but the README warns it can burn through usage limits quickly.

Read more on interesting repos · GitHub

Agents can't normally look at video. Watch fixes that by turning a URL or local file into evidence the agent can read: frames taken at points in time, plus a transcript. You ask questions and the agent answers with timestamps.

It has two engines. If you set a Gemini API key, the whole video, picture and sound, goes to Google's video model and its timestamped answer comes back. The local engine runs on your machine with ffmpeg and yt-dlp, extracts frames, and reads native captions first. For videos without captions it can fall back to local WhisperX, Groq or OpenAI transcription.

It installs as a plugin in Claude Code (desktop app, VS Code or terminal) or as a skill in Codex and other Agent Skills hosts. It does not work in Claude Chat or Cowork. It never switches engines on its own: if Gemini fails, it reports the error and you decide whether to rerun locally.

Read more on interesting repos · GitHub

Strong models are good at understanding a codebase and deciding what to fix, but running them through every edit is expensive. This skill splits the work. The strong model audits and writes the spec, and it never changes your source code. The plans are the output.

A run maps the repo and finds its build, test and lint commands. Parallel subagents then audit nine areas, including correctness, security, performance, tests and docs. The main model re-reads every cited file and line to drop false positives. You get a ranked table and choose which findings become plans.

Each plan is a markdown file written for a weak executor. It holds file paths, current code, repo conventions, a verification command per step, and STOP conditions for when the code doesn't match. Any agent or human can pick it up. The skill can also dispatch a cheaper model in a git worktree and review its diff, but merging stays with you.

Read more on interesting repos · GitHub

AI coding agents often over-build. Ask for a date picker and you may get a new library, a wrapper component and a stylesheet. Ponytail gives the agent a habit instead: stop at the first option that works, and write only what the task needs.

Before coding, the agent walks a seven-step ladder. Does this need to exist? Is it already in the codebase? Does the standard library, the platform or an installed dependency do it? Can it be one line? Only then does it write the minimum. It reads and traces the relevant code first, so it is lazy about the solution but not about understanding.

The README says validation at trust boundaries, data-loss handling, security and accessibility are never cut. It compares itself with a no-skill agent, a terse-prose skill (caveman) and a plain 'YAGNI + one-liners' prompt. In the author's own benchmark (Haiku 4.5, 12 tasks, 4 runs each), lines of code fell about 54% on average. The gain is near zero where code is already minimal.

Read more on interesting repos · GitHub

AI Berkshire is a collection of skills, which are prompt-and-workflow files you install into Claude Code or Codex. Each one is a slash command such as /investment-research or /earnings-review. Together they cover company research, earnings reading, industry screening, portfolio review and tracking whether a buy thesis still holds.

The main idea is to avoid the balanced, noncommittal answer you get from asking a chatbot about a stock. The skills ask for a pass, fail or grey-zone verdict with price ranges. They split the analysis across four viewpoints that can disagree: business model, financial valuation, contrarian risk and long-term certainty. Team skills like /investment-team launch four agents in parallel. Each searches and scores on its own, and a team lead then combines the results.

The README also describes guardrails: a rating for how much information is available, a list of quick-reject red flags, a check against consensus thinking, and a Python helper that verifies figures such as market cap using exact decimals. The author reports personal trading returns and publishes a large index of generated reports. Those are the author's own claims and are not independently verified. The README warns that the deep skills use a lot of tokens.

Read more on interesting repos · GitHub

A one-shot prompt asks an agent to do something once. A loop adds feedback: the agent acts, checks the result, uses what it learned, and either repeats or stops. This repo argues that bounded loops are easier to trust and reuse than open-ended instructions like "keep improving this".

The repository has two parts. One is the Loop Library website, a public catalog where people and agents can browse loops and copy their prompts, with no install needed. The other is Loopy, an optional skill that gives your agent a guided workflow on top of that catalog.

Loopy has nine paths: discover, find, audit (Loop Doctor), adapt, craft, run, debrief, save and publish. It works in bounded passes and returns a receipt of what it did. It does not start schedules, publish or send messages without your approval. Saved loops go into a LOOPS.md file in your project.

Read more on interesting repos · GitHub

Doing PR well takes many separate jobs: watching the news, deciding whether you have standing to comment, writing angles, finding the right reporter, and checking your claims. Newsjack turns each job into a skill, which is a Markdown file of instructions your agent reads. You call a skill by name, such as /angle-generator, or describe what you want and the agent picks one.

The skills fall into four groups. Detect finds and filters stories. Act drafts headlines, pitches, holding statements and media lists. Strategize helps you work out your story and plan a calendar. AI visibility covers writing and testing content so AI answers can reuse it.

Most skills run in any agent. Some need a live news index or saved monitoring state, so they work best in a local agent such as Claude Code, Codex, Hermes or OpenClaw. Some also use a free Medialyst account for news search and journalist data. The README has a table showing which skill runs where.

Read more on interesting repos · GitHub

Search engines mostly return editorial pages and older material. The useful recent talk about a person, tool or event is often in Reddit threads, X posts, YouTube transcripts and prediction markets, and each of those sits behind its own API and login. /last30days is a skill your coding agent runs: you type a topic, and it queries those sources over the past 30 days.

It scores each result by how much people engaged with it, for example upvotes, likes, views or Polymarket trading volume. Then the agent synthesizes the top items into one brief. The README frames this as social relevancy rather than SEO relevancy, and it says a heavily upvoted thread counts for more than a blog post few people read.

Reddit, Hacker News, Polymarket and GitHub work with no setup. Other sources like X, YouTube and TikTok need your own keys or browser sessions, which a first-run setup wizard helps with. The README compares it to Google, ChatGPT, Gemini and Claude, none of which cover all of these platforms at once.

Read more on interesting repos · GitHub

Product managers rely on many frameworks: opportunity solution trees, assumption mapping, lean canvas, RICE, PRD templates. A general chatbot tends to give loose text. This repo packages each framework as a skill file that an AI assistant loads when the topic comes up.

There are three layers. Skills are single-purpose knowledge files, such as writing a PRD or running a pre-mortem. Commands are slash workflows that chain skills. For example, /discover runs brainstorm-ideas, identify-assumptions, prioritize-assumptions and brainstorm-experiments in order. Plugins group skills and commands by area, like discovery, strategy or execution.

It is built for Claude Code and Claude Cowork. The skill files use the common SKILL.md format, so they also work in Codex, Gemini CLI, OpenCode, Cursor and Kiro. The slash commands are Claude-specific. Codex installs them but does not run them as commands.

Read more on interesting repos · GitHub

Chinese writers who want images for an article often get generic illustrations or slide-like infographics. This skill gives the AI agent a fixed visual style and a method, so each image explains one idea from the text instead of just decorating it.

The agent reads your article, Markdown, Notion content or a single topic. It picks one key idea per image, such as a judgment, a flow or a state. It then invents a low-tech, slightly absurd physical metaphor and sends each image to the image model separately. You get a shot list of 4 to 8 images, then PNG files.

The look is a pure white background, thin black hand-drawn lines, lots of empty space and a few red, orange and blue handwritten Chinese notes. The recurring character is Xiaohei, a solid black figure with white dot eyes and thin legs, who must take part in the main action. The README says the example images only calibrate style and should not be copied.

Read more on interesting repos · GitHub

Codex plugins add extra abilities to the Codex coding agent. This repo is a library of working examples. Each one lives in its own folder under plugins/<name>/ and must have a .codex-plugin/plugin.json manifest.

Beyond the manifest, a plugin can include skills, an .app.json, an .mcp.json for tool servers, agents, commands, hooks and assets. You can open any example to see how those pieces fit together.

The repo also has a default marketplace file at .agents/plugins/marketplace.json that points at the plugins/ directory. Users who log in with an API key have a separate marketplace file. The README is short and does not explain installation or the plugin format in detail.

Read more on interesting repos · GitHub

A coding agent can write code, but it won't follow a steady process unless you tell it to. ECC packages that process once. The README describes the loop as plan, test, implement, review, verify, remember, improve.

You install it as a plugin (ecc@ecc in Claude Code) using a guided setup run through npx. It adds agents for planning, review, build repair, security and architecture. It adds skills for things like TDD, research and docs. Hooks enforce steps and save session summaries. Rules are optional, and you pick them by language or project.

It works best with Claude Code. Codex has a supported sync path, and the guided installer also covers Kimi Code. Cursor, OpenCode, Gemini, Zed, Copilot and others get adapters with fewer features, so check the README's support matrix first. It also includes AgentShield, which scans prompts, hooks, MCP config, permissions and secrets. The repo is MIT-licensed. A paid hosted GitHub App for private repos also exists.

Read more on interesting repos · GitHub

AI coding agents tend to produce interfaces that look alike: the same layouts, fonts and spacing. Taste Skill is a collection of SKILL.md files that tell the agent how to design instead. They cover layout, typography, motion and spacing, and the model reads them, not you.

The main skill reads your brief, infers a design language, and uses three 1-10 dials at the top of the file: DESIGN_VARIANCE, MOTION_INTENSITY and VISUAL_DENSITY. You change the numbers to get calmer or bolder results. Other skills target specific styles (soft, minimalist, brutalist), redesign existing projects, or push the model to finish its output without placeholder comments.

The repo also has image-generation skills for website comps, mobile screens and brand-kit boards. You make reference images with ChatGPT Images or a similar tool, then hand them to Codex, Cursor or Claude Code to build. The image-to-code skill chains the steps: generate references, analyze them, write the code.

Read more on interesting repos · GitHub

AI coding agents tend to forget. Each new task starts from scratch, and lessons from earlier bugs and decisions are lost. Compound Engineering is a plugin that gives the agent a repeatable workflow and a place to write down what it learned.

The core loop has six steps: brainstorm requirements, plan the implementation, do the work, simplify the code, review it, then compound the learning. The last step writes a note into docs/solutions/. Later brainstorm and plan runs read those notes as background, so they don't repeat old mistakes.

The README says to put most effort into planning and review, and less into execution. Beyond the loop, the plugin has skills for debugging, git and PR handling, browser testing, and a hands-off mode called lfg. It supports 14 agent hosts, including Claude Code, Cursor, Codex, Cline and GitHub Copilot.

Read more on interesting repos · GitHub

GTM teams do a lot of repeatable work that depends on scattered context: CRM records, docs, spreadsheets, call transcripts and campaign notes. This repo packages that work as skills that coding agents such as Codex, Claude Code and Cursor can follow.

Skills are grouped by team in folders: marketing, customer advocacy, sales and revops, customer support, legal operations, GTM ops and content ops. Each folder has a README and, where available, SKILL.md, SETUP.md and SCHEMA-MAP.md. A registry CSV helps you find the closest match. Tools connect through Zapier MCP and the Zapier SDK.

The README says this is not just a prompt library. The focus is output a person can review, with permissions, approval gates and audit trails. It tells you to keep a human approval step before sending messages, updating CRM records or publishing assets.

Read more on interesting repos · GitHub

A general-purpose AI agent can write code, but it often lacks the habits of a security analyst: which tool to run on a memory dump, what to check first, how to confirm a result. This repo packages that kind of practitioner guidance as skills an agent can read when a task calls for it.

Each skill follows the agentskills.io open standard. It has YAML frontmatter so the agent can find the right skill quickly, structured Markdown with prerequisites and steps, and reference files for deeper detail. The skills span dozens of domains, from cloud, SOC and threat hunting to malware analysis, OT/ICS and AI security. The README's counts vary slightly (817 or 818 skills, 29 or 34 domains).

Skills are mapped to the frameworks that fit them: MITRE ATT&CK, NIST CSF 2.0, MITRE ATLAS, D3FEND, NIST AI RMF and MITRE's Fight Fraud Framework. The README contrasts it with repos of wordlists, payloads or exploit code, since this one targets the agent's decision workflow. It is a community project, not affiliated with Anthropic. It includes offensive and dual-use techniques meant only for authorized testing, research, defense and education.

Read more on interesting repos · GitHub

Out of the box, Claude knows little about how your team works. These plugins fix that by bundling skills, slash commands, connectors and sub-agents for one job function, such as sales, customer support, legal or finance.

Each plugin is plain markdown and JSON. Skills hold domain knowledge Claude draws on automatically. Commands are actions you call by name, like /sales:call-prep or /data:write-query. Connectors use MCP servers to link Claude to tools such as Slack, HubSpot, Snowflake or Jira. There is no code to run and no build step.

The plugins are generic starting points, and the README expects you to edit them. You can swap connectors in .mcp.json, add your own terminology and processes to skill files, or make new plugins with the included cowork-plugin-management plugin.

Read more on interesting repos · GitHub

AI-generated prose has habits: throat-clearing openers, binary contrasts, short dramatic fragments, and a steady sentence rhythm. Readers notice these quickly. This project collects those habits into a skill that a model reads before it writes or edits.

The core is a SKILL.md file with the main rules. Three reference files sit beside it: a list of phrases to remove, a list of structural patterns to avoid, and before/after examples. The reference files load on demand when used through the API.

It also includes a scoring step. The model rates a draft from 1 to 10 on directness, rhythm, trust, authenticity and density, and revises if the total falls below 35 out of 50. It is plain text instructions, so there is no code to run or maintain.

Read more on interesting repos · GitHub

Cursor's agent can do more when it has the right skills, rules and tool connections. This repository collects official plugins that package those pieces, so you don't have to write them yourself. It also shows the plugin format, so you can see how one is put together.

Each plugin is its own folder with a manifest file. Inside, it can hold skills (markdown instructions for the agent), rules, and MCP server definitions that connect the agent to outside services. A root manifest lists every plugin for the marketplace.

The list mixes two kinds of plugin. Some change how the agent works on code, such as review, parallel agents and memory updates. Others, in third_party/, connect it to business tools like email, CRM, finance and analytics. Some plugins come from individual authors rather than Cursor.

Read more on interesting repos · GitHub

Your notes live in an Obsidian vault, but AI tools usually can't see them. This plugin starts a Model Context Protocol (MCP) server inside Obsidian. MCP is a standard way for AI clients to call tools, so the client can ask the plugin to open, create or change files.

It speaks two transports. Claude Code connects over WebSocket and finds your vault on its own through the /ide command. Claude Desktop and other clients connect over HTTP with SSE, on port 22360 by default. Claude Desktop needs the mcp-remote bridge, because it doesn't talk to HTTP servers directly.

The HTTP side deliberately uses the older 2024-11-05 HTTP with SSE spec, because the README says current clients don't yet support the newer Streamable HTTP. Tools are split into shared, IDE-only and MCP-only groups, and the README explains how to add your own.

Read more on interesting repos · GitHub

AI coding agents tend to jump straight to code, skip tests, and drift from what you asked for. This repo packages the habits of careful engineers as skills: Markdown files with steps, verification gates, and tables that counter an agent's excuses for cutting corners.

The skills follow six phases: define, plan, build, verify, review, ship. Nine slash commands such as /spec, /plan, /build, /test, /review and /ship map to those phases and switch on the right skills. Skills can also trigger on their own. Designing an API, for example, brings in the api-and-interface-design skill.

Because the skills are plain Markdown, they are not tied to one tool. The README gives install routes for Claude Code, Cursor, Codex, Gemini CLI, Antigravity, Copilot, Windsurf, OpenCode, Kiro and Command Code. It also points to the open skills CLI, which installs into many agents at once. The README names no direct alternatives.

Read more on interesting repos · GitHub

Writing a paper involves many separate chores: finding sources, formatting citations, checking that claims match their sources, and answering reviewers. This project packages those steps as Claude Code skills you run with slash commands from the CLI or an IDE.

The pipeline runs from research to writing, review, revision and finalization, and it stops for your approval at each stage. Two integrity gates (Stages 2.5 and 4.5) run a blocking checklist of seven known AI-research failure modes, such as hallucinated results and citation errors. An opt-in claim audit can fetch a cited source and judge whether it supports the claim.

The README says this is not a fully autonomous AI scientist and not a tool for hiding AI use. It argues for human-led verification, and a Style Calibration feature learns your voice from past work. One caveat from the README: the claim audit has only been tested with a stub judge, and no live-judge calibration result is recorded yet.

Read more on interesting repos · GitHub

Coding agents often build the wrong thing, talk too much, write code that doesn't run, or pile up messy design. This repo is the author's answer: a set of skill files, each one a short instruction set the agent follows when you type a command like /grill-me or /tdd.

The skills tackle those four problems in turn. Grilling skills have the agent question you before it builds, and keep a shared glossary and decision records so it uses your project's terms. Others push a red-green-refactor test loop, a gated bug-diagnosis routine, and regular reviews of code design.

The README contrasts it with GSD, BMAD and Spec-Kit, which it says own the whole process. These skills are meant to be small and composable, to work with any model, and to be edited. Some can only be invoked by you; others the agent can reach for on its own.

Read more on interesting repos · GitHub