标签：#skills

I have built 114 Claude Code skills. Most of them are engineering plumbing. But five of them exist for one reason only: my executive function has specific, repeatable holes, and I got tired of falling into the same ones. These five are not productivity hacks. Each one maps to a named ADHD deficit, and each one fills it the same way every time so I do not have to re-improvise around my own brain at 2pm. If you want the broader system this sits inside, start with my Claude Code ADHD workflow and the CLAUDE.md guide . This post is the skills layer specifically. What Is a Claude Code Skill? A skill is a named, repeatable workflow you invoke with a slash command. Instead of re-prompting Claude Code from a blank slate every time ("okay, help me figure out what to work on, here is my situation again..."), you type /adhd-task-triage and it runs the same defined steps it ran yesterday. For an ADHD brain, that determinism is the feature. The skill does not depend on me remembering how to drive it. It just runs. Custom skills live in a .claude/skills/<name>/SKILL.md file that describes what the skill does and when it should fire. You can build one for any gap you fall into more than twice. 1. adhd-task-triage: Energy-Based Prioritization The gap it fills: task initiation paralysis. Standard task managers sort by priority or deadline. That assumes you can act on the top item by willpower. ADHD does not work that way. The top-priority task and the task you can actually start right now are often different tasks, and trying to force the high-priority one when your initiation circuit is offline produces zero output and a guilt spiral. adhd-task-triage sorts by available energy , not importance. You tell it where you are (wired, foggy, depleted), it looks at the work in front of you, and it hands back the task that matches the state you are actually in, not the one you wish you were in. /adhd-task-triage Why it helps specifically: it removes the moral framing. The question stops bei

For months, the most interesting model at Anthropic was one we could not use. Mythos was the internal system the company said was too capable to release, the one that found software vulnerabilities at a level that tripped its own safety thresholds. On June 9, 2026, that tier went public for the first time, as Claude Fable 5. Opus 4.8, the model anchoring production coding agents, suddenly had a successor that's a full capability class above it. This raises two questions for anyone running coding agents. The practical one is whether you should move your fleet from Opus 4.8 to Fable 5. The bigger one is whether a Mythos-class model, the tier Anthropic held back as too capable to ship, lives up to what the name promised. This article answers both, and the numbers tell a more interesting story than the announcement did. We ran both models through the same evaluation, close to 1000 shared scenarios scored twice each, once with no skill supplied and once with the relevant skill in context. The short answer, as of mid-2026, is that Opus 4.8 is still the better value for most agent fleets, and the gap between the Mythos hype and the measured reality is the real story in the data. A Mythos-class model is a tier of Claude that sits above the Opus class in capability . It reaches a threshold Anthropic considers high-risk, particularly at discovering and exploiting software vulnerabilities. Fable 5 and Mythos 5 are the same underlying model with the same capabilities. What separates them is the safeguards: Fable 5 is the public version that ships with safety classifiers, while Mythos 5, restricted to approved partners, runs without them. What the industry expected from a Mythos-class model Before launch, the speculation was not subtle. Across Reddit, X, and a run of explainer posts, Mythos was framed as the model that would change how agents work, not just how well they answer. The recurring predictions clustered around four capabilities: Restructuring a large codebase in one c

Find the answers to some of the most common GitHub-related questions. The post GitHub for Beginners: Answers to some common questions appeared first on The GitHub Blog .

title: Your AI Agent Should Not Be Locked to One LLM Provider published: false description: Why serious AI agents need a provider-agnostic architecture, model routing, fallback, and a unified API gateway. tags: ai, llm, agents, architecture Your AI Agent Should Not Be Locked to One LLM Provider Most AI agent prototypes start the same way. You pick one model provider. You install one SDK. You write a few prompts. You add tool calling. You build a demo. It works. Until it does not. The moment you want to try another model, reduce cost, add fallback, improve latency, or support different task types, your simple agent starts turning into a messy collection of provider-specific logic. That is when you realize something important: A real AI agent should not be locked to one LLM provider. If you are building a personal AI agent, coding assistant, research assistant, internal workflow agent, or AI-native product, the model should be replaceable infrastructure — not a hardcoded dependency. The Problem with Single-Provider Agents A simple agent architecture often looks like this: CopyUser ↓ Agent ↓ One LLM Provider ↓ Response This is fine for a proof of concept. But real-world agent systems need more flexibility. Different tasks often need different models: Task Better Model Strategy Quick summarization Fast, low-cost model Complex coding Strong coding model Long document analysis Long-context model Reasoning-heavy planning Reasoning model Multilingual writing Model strong in that language Background automation Cheap and reliable model Production fallback Backup provider If your agent is deeply coupled to one provider, every optimization becomes harder. You cannot easily answer questions like: What happens if the provider is down? What if latency spikes? What if another model is cheaper for simple tasks? What if a new model is better for coding? What if a user wants Claude for writing but GPT for structured reasoning? What if you want to route Chinese tasks to a different mod

The signal hidden in this week's GitHub trending Two agent-shaped repositories cracked the daily GitHub trending board this week. The first is mvanhorn/last30days-skill , a Claude-style skill that researches a topic across Reddit, X, YouTube, Hacker News, and Polymarket, then synthesizes a grounded summary. The second is NousResearch/hermes-agent , billed as "the agent that grows with you" — a persistent agent runtime that compounds context across sessions. Both ranked the same week. Both are skill-shaped: a manifest, a trigger, a set of instructions, and a runtime expectation. This is the first time I have seen two skill repos chart simultaneously on GitHub trending. Most observers will treat them as cool side projects, fork them, star them, and move on. They are cool side projects. They are also a phase transition that the agent ecosystem has been edging toward for nine months. By Q4 you are going to wish you had read this signal in early June, because the dependency-graph problem about to land in production agents is the same one the npm ecosystem ran into between 2011 and 2018 — except faster, less tooled, and with a much larger blast radius. This post is about that phase transition. The benchmark coverage of skills is everywhere; what you cannot easily find is a working operational model for managing them at fleet scale. I am going to give you one. What actually shipped this week Let me anchor on the facts before I extrapolate. last30days-skill (mvanhorn) is a single skill bundle. Its SKILL.md tells the host agent: when the user asks for recent news, controversy, or sentiment on a topic, run a structured multi-source fetch — eight queries minimum, across five platforms, with a freshness window of 30 days — then synthesize. The skill ships with prompt scaffolding, query templates, and a synthesis rubric. It is roughly 600 lines including instructions and helper scripts. Installation is a git clone into your skill directory, no package manager, no version negotia

A2A has become like a standard for enabling agent to agent communication, we could use the a2a-sdk for running and configuring the a2a server and its features such as agent card, agent skills, agent executor, request handler etc. However we are going to go with a simplified approach here with strands where the agent card will be fetched automatically. Let's get started! Server Initialize a uv project for the a2a server and switch to that directory. uv init ~/strands-a2a-server cd ~/strands-a2a-server Add the required packages. uv add python-dotenv == 1.2.2 strands-agents[a2a] == 1.42.0 Change the code in main.py to look like below. $ cat main . py from dotenv import load_dotenv from strands import Agent from strands.multiagent.a2a import A2AServer load_dotenv () def main (): agent = Agent ( callback_handler = None , description = " A sample strands agent " , model = " us.amazon.nova-micro-v1:0 " , ) a2a_server = A2AServer ( agent = agent ) a2a_server . serve () if __name__ == " __main__ " : main () I like the simplicity here, as you see above, it's quite simple to start a basic a2a server from with in strands, with just a couple of lines of code, we didn't have to install the a2a-sdk separately. Run the code, to start the a2a server. $ uv run main.py INFO: Started server process [18006] INFO: Waiting for application startup. INFO: Application startup complete. INFO: Uvicorn running on http://127.0.0.1:9000 (Press CTRL+C to quit) Client Let's now do the client part on a separate terminal. Initialize the project and switch the directory. uv init ~/strands-a2a-client cd ~/strands-a2a-client Modify main.py code to look as follows. import asyncio from strands.agent.a2a_agent import A2AAgent async def main (): agent = A2AAgent ( endpoint = " http://localhost:9000 " ) agent_card = await agent . get_agent_card () print ( " Invoking remote agent with agent card: " ) for key , value in agent_card : print ( key , " : " , value ) print ( ' - ' * 20 ) while True : prompt = input

Anthropic published a thoughtful guide to making skills. It is worth reading, but it's a map of work you should not have to do. The Claude Code team wrote a piece on how they use agent skills . If you make skills, read it. It is honest and tells you something important: making a good skill is real work. Here's what the guide covers. It sorts skills into nine categories. It explains progressive disclosure, where the agent knows which files to load and when. It covers scripts, config files, combining skills together, and writing the description so the model reaches for the skill at the right moment. All of that is true and useful. It is also a lot to learn. And most of it exists only because you are doing the work by hand. We're SkillsCake . We make and score agent skills all day. So we read this guide a little differently than someone meeting skills for the first time. Here's what we think. Skills are infinite The guide splits skills into types: library reference, verification, and so on. That is a helpful way to teach a class. It is not what a skill actually is. A skill is prose that tells an agent how to do one thing, sometimes with scripts attached. The set of possible skills is not nine boxes. It is every job you could describe in writing; it's infinite. Categories are how a person gets a handle on something that open-ended. They are scaffolding for learning, not the shape of the thing. This matters because the moment you think in categories, you start bending your skill to look like the example in its bucket. Your real job rarely fits the bucket. The best engineered skill is the one written for your exact task, by an expert. Doing it yourself might not be worth it Progressive disclosure, scripts, config, descriptions tuned for the model, gotchas earned by failing, and eval loops: none of that is busywork. It's how a good skill gets built by hand. The guide is not overcomplicating anything. It is being honest about what the manual path costs. But that is the poin

I’ve spent a lot of time lately thinking about why some LLM agents feel "intelligent" while others just feel like chatbots with a slightly better prompt. It almost always comes down to how the system handles memory. When we treat the context window as the only place for state, we hit a ceiling very quickly. To build an actual agent, we have to move away from "one big prompt" and toward a layered memory architecture. Agentic Memory can be categorized in 4 layers by their function: Working Memory: The current context window. It's our RAM—fast, essential, but wiped clean after every session. Semantic Memory: The Vector DB or knowledge base. This is where the "world rules" and global conventions live. It’s the reference manual the agent checks to stay aligned. Procedural Memory: The "how-to" layer. Instead of stuffing every tool description into the prompt, the agent maintains a lean index of skills and pulls in the full implementation only when a specific task triggers it. This keeps the context window clean. Episodic Memory: This is the hardest part. It's the ability to distill a past interaction into a reusable insight. The real engineering challenge here isn't storage—it's the "forgetting" logic. Deciding what is noise and what is a core pattern is where most frameworks still struggle. Depending on the use case, the architecture changes: Reflex Agents: Just Working Memory. Support Agents: Working + Procedural. Coding Agents: The full stack. The gap between a demo and a production-ready agent is usually the distance between simple RAG and a functioning episodic memory. The ability to compress experience into a usable state is still a significant hurdle. Which of these layers are you currently implementing, and how are you handling the "forgetting" logic in your episodic memory?

The Question Nobody Wants to Ask: Does Your Skill Actually Help? You spent an afternoon crafting a carefully structured Skill for your agent. Clear steps, thorough edge-case notes, well-formatted output requirements. You tested it manually a few times, the outputs looked great. You shipped it. Three weeks later, you notice that some task success rates have gone down compared to before the Skill existed. This is not a hypothetical. In May 2026, Microsoft Research published two concurrent papers — SkillLens ("From Raw Experience to Skill Consumption") and SkillOpt ("Executive Strategy for Self-Evolving Agent Skills") — that measured this failure mode at scale. Their finding: negative transfer happens in 25% of cases , and you cannot reliably identify the bad skills just by reading the text. One paper answers "why skills sometimes backfire." The other answers "how to make skills systematically better." Together they sketch a new paradigm for agent capability improvement. Part One: SkillLens — Mapping the Full Skill Lifecycle A Skill Is Not a Point — It's a Pipeline Most practitioners think of a Skill as "a block of text instructions for an agent." SkillLens decomposes this into a three-stage lifecycle : Stage 1: Experience Generation Target model M runs training tasks, producing an experience pool of trajectories (both successes and failures) ↓ Stage 2: Skill Extraction Extractor model E distills the experience pool into a structured skill document — procedural knowledge under a fixed budget ↓ Stage 3: Skill Consumption The same target model M, equipped with the extracted skill, is evaluated on held-out test tasks Notice there are two distinct roles in this chain: the Extractor (distills knowledge from trajectories) and the Target (consumes knowledge to improve task performance). SkillLens's central insight is that these two roles are independent — a strong task executor is not necessarily a strong extractor, and vice versa . Two New Metrics: EE and TE To separate thes

{/* JSON-LD schema is generated server-side in app/blog/[slug]/page.tsx , do not re-add an inline block here, it crashes<br> MDX&#39;s Acorn parser on the leading <code>{</code>. */}</p> <h2> <a name="tldr" href="#tldr" class="anchor"> </a> TL;DR </h2> <p>In February 2026, Snyk published the <a href="https://snyk.io/blog/toxicskills-malicious-ai-agent-skills-clawhub/">ToxicSkills audit</a>, the first large-scale security review of the public Claude Code skills ecosystem. It scanned 3,984 skills from ClawHub and skills.sh. Findings:</p> <ul> <li><strong>13.4%</strong> contained critical-level issues</li> <li><strong>36%</strong> carried prompt-injection payloads</li> <li><strong>1,467</strong> distinct malicious payloads</li> <li><strong>91%</strong> of confirmed malware combined natural-language jailbreaks with executable shell payloads</li> </ul> <p>If you install a Claude Code skill today without reading its source, the probability that it can read your env vars, exfiltrate <code>~/.ssh/</code>, or chain a bash pipeline that bypasses your deny rules is real and measurable. This post is the cheat sheet for evaluating a skill before you install it. The CTA at the bottom is <a href="https://dev.to/skillvault">SkillVault</a>, the bundle we ship for teams who want this work already done.</p> <h2> <a name="why-the-question-is-suddenly-loadbearing" href="#why-the-question-is-suddenly-loadbearing" class="anchor"> </a> Why the question is suddenly load-bearing </h2> <p>Claude Code skills shipped as an open spec in December 2025. By March 2026, MCP downloads were tracking at 97 million per month, and the most-installed marketplace skill had passed 564,000 installs. <a href="https://venturebeat.com/security/claude-code-512000-line-source-leak-attack-paths-audit-security-leaders">Anthropic&#39;s source leak</a> on March 31, 2026 made the abstract attack surface visceral: the <code>bashSecurity.ts</code> module has 23 numbered security checks, suggesting each was a real incide

Overview We built the Ota skill because too much "AI repo automation" is still fake confidence. An agent clones a repo, finds a plausible command, edits the right file, and looks smart right up until it does something expensive and stupid. It runs the wrong test path. It installs tools globally because local setup was unclear. It patches around a missing service as if the repo were healthy. That failure is usually blamed on the model. Most of the time it is a repo problem. The repository never made its real operating path explicit enough for the agent to follow without guessing. Ota already gives the repo a machine-readable contract through ota.yaml . The skill exists to teach agents how to behave around that contract: what to trust, what to run, and when to stop instead of improvising. It is not a replacement for ota.yaml . It is not an MCP server. It is not a hidden automation layer. It is the missing operating guide for agents working in Ota repos. Why an Ota skill exists We kept seeing the same pattern: the agent was fast, but the repo was vague. Without a repo-specific operating guide, an agent may see several possible paths: run the command from the README copy the command from CI infer setup from package.json , pyproject.toml , or go.mod run a broad test command because it looks conventional install tools globally because a local command failed patch around a missing service instead of identifying the readiness gap Some of those choices work. Some are dangerous. Some look fine locally and still miss the only verification path that matters. Our view is simple: if a repo has ota.yaml , that file should beat README prose, shell folklore, and whatever command happens to look familiar. Declared tasks, writable paths, setup requirements, and validation commands should be treated as contract facts. The skill exists to make that behavior explicit across agents that support skills. What the skill teaches an agent The official skill lives in ota-run/skills . It is aime

Discover how to use VS Code to interact with GitHub and maintain your projects. The post GitHub for Beginners: Getting started with Git and GitHub in VS Code appeared first on The GitHub Blog .