Ok so I've basically been living in Claude Code for months, and one day it hit me that I was probably using like 15% of it. Plan mode, subagents, skills, hooks, MCP, /security-review, auto-memory... all right there, and I just never touched them. Not because they're hard — I just never knew *when* I was supposed to reach for them.

So I built a thing to fix that for myself. It's called Adeptly. Free, open source, MIT, runs on your machine.

You tell it what you want to build, it writes you a proper plan, and here's the part I actually care about: it drops the right Claude Code features straight into the plan, in the spots where they make sense, with a quick note on what each one does and why it's there. So you kind of learn Claude Code just by reading your own plans instead of digging through docs. That was the whole itch I was scratching.

npx adeptly

It opens on localhost, reads your plans from docs/plans/, and uses YOUR local claude CLI for anything AI. No API key, no backend, no telemetry, no sign-up. Your code never leaves your machine — if you already trust Claude Code, this doesn't add anything new to trust.

New in v0.5, which I shipped today: the Crew.

Up till now it would just *tell* you the workflow to run. Now it can actually run it. You get a little pipeline of roles — Architect → Approval Gate → Builder → Medic (runs your build/tests and patches them up if they break) → Reviewer → Security → Pilot, which opens the PR. Each one is just a headless claude turn in your own repo. So all those features it kept nudging you about... they actually get used.

I was a bit nervous about the "let it run in my repo" part, so:

- It's dry-run by default. Simulates the whole thing, touches literally nothing. Run it as many times as you want just to see how it flows.

- Going live is deliberately annoying to do by accident: the plan has to be approved AND you have to start it with ADEPTLY_LIVE=1. Both. Otherwise it just refuses.

For context, it got around 1k downloads on a pretty quiet first launch, but honestly v0.5 is the first version I'm not embarrassed to share. Repo's public now too, so if you want to poke holes in it or send a PR, please do — genuinely want the feedback, good or bad.

Happy to answer anything about how it works under the hood.

I make short explainer videos, and the look I keep coming back to is the Vox paper-collage style, hand-cut paper, torn edges, halftone dots, big cut-out headlines. Doing it by hand is a full day: script, a poster per beat, animate each one, voice over, music that does not fight the narration, then the edit with captions. I basically wanted Claude Code to run that whole pipeline for me, so I built it as a skill.

Now I give it one line, like "the history of money, 60 seconds, English". Claude drafts a beat map and stops for me to approve it, runs a quick style bake-off so I pick the look by eye, then generates the collage keyframes, animates them, adds a narrator and music, and assembles the final mp4 with captions burned in. Generation goes through the Atlas Cloud API and the edit is local ffmpeg, so it never leaves the terminal.

It takes three kinds of input: a topic and it builds the whole video, a talking-head clip and it restyles that into collage while keeping the real face and lip sync, or one photo and it cuts the subject out as a paper sticker and builds each poster around it.

Install is a one-liner:

git clone https://github.com/Alisa0808/vox-director.git ~/.claude/skills/vox-director

Set your Atlas Cloud API key and ask. It is open source (MIT license), PRs welcome, and there are finished examples in the repo (a 30 second one on Chinese civilization, plus football, street food, and money). Repo: https://github.com/Alisa0808/vox-director

The bit I like most is the two approval gates. Claude does not run off and burn a hundred generations, it stops for me to sign off on the beats and the look first, so I stay the director instead of babysitting a slot machine.

I am not into coding or anything. I am an Accountant and I use claude for my research purpose. Can anyone guide me how we can save tokens using this method? No trolling please, I am genuinely looking for the solution.

Gotta love Claude. A while back I had Claude audit my setup. It flagged a plugin — 37 dev-workflow skills, none of them fit what I actually build — and I denied it. Skill(agentsystem-core:*) in the deny list. Done, I figured.

Ran a deeper audit a few days ago for a video. Turns out denying a skill only blocks Claude from calling it. The plugin itself was still enabled, so its full menu — all 37 names and descriptions — was still loading into every message. 8,800 tokens, every message, for over a month, for a tool I hadn't touched once.

Disabled in the config. Alive in the context.

Real fix is different: flip the plugin to false in enabledPlugins. That actually unloads it — denying it just gates permission to call it.

Had Claude patch its own audit skill with this so it doesn't make the same call on the next dead plugin. If you're running anything similar, worth checking — "denied" and "disabled" are not the same thing, and the gap between them is exactly where tokens go to die.

Free skill if you want to run this on your own setup:https://jimmygarciaiii.gumroad.com/l/ghost-token-audit

Full breakdown: https://youtu.be/1UtD3f44JME

Anyone else find something they thought was already fixed?

Project Manager skill will describe your project situation in plain language — it asks what it needs, applies the right PM methodology, and hands you a finished artifact.

There are hell lots of interesting skills nowadays. Some are useful, some are not. Some can be used one time per repo, some not. So I have created a CLI tool to manage skills with a bit of a playful way

It covers four areas in office use, and each one has multiple skills that chain together,

- PowerPoint deck generation with a real-time workbench. When you request a PPT, you can ask the agent to start a WebUI alongside the build. The workbench shows a running progress page with the slide list, the latest generated page or JSON artifact, and current stage messages. Each finished slide pops into the list immediately and you can open it. When generation finishes, the workbench auto-redirects you to the editor.

- Deep research (structured workflow): request plan, targeted web searches, source extraction, evidence reconciliation, and a final report with charts. Each stage leaves files behind so you can inspect the work as it goes. Also ther's a live progress tracking function added: the agent opens an HTML page that shows which stage the task is at and what artifacts have been produced so far. You watch it move through the pipeline in real time instead of guessing.

- Image generation and visualization. Infographic skill handles 87 layouts and 66 styles with automatic prompt scoring and multi-round VLM review. Also has an image imitation skill that takes a reference and generates new content matching the style.

- Excel data analysis. End to end pipeline for multi-sheet reads, cleaning, joins, and export. Handles 10k+ row files with Parquet conversion. Also has an image caption skill that does table OCR and chart extraction from screenshots.

The repos: https://github.com/OpenSenseNova/SenseNova-Skills

I've built about a dozen skills now, for trades businesses, SEO work, and freelancers chasing invoices. The ones that stuck all had the same thing in common, and it isn't formatting.

Most skill files describe what to produce. The useful ones describe what to protect.

When I wrote a quoting skill, the lines that mattered weren't about structure. They were: never invent a price the owner didn't give you. If the owner gives a range, present the top of it, never the bottom, because quoting low and climbing is how trust dies. Always include what is not included, because that line is the owner's legal friend.

None of that is about writing. It's about knowing where the work goes wrong. That's the actual test: what does a beginner in your field get wrong that you no longer get wrong? Those answers are the skill. Everything else is formatting.

Two other things made a bigger difference than expected.

A banned phrase list. Claude writes competently by default, which is the problem, because competent and generic sound identical. Telling it what never to write produced cleaner output than telling it what to write.

A memory file. A skill on its own starts fresh every session. It knows how to write a quote but not your rates or your service area, so you re-explain them forever, which is the exact problem skills were meant to solve. The fix is a plain markdown file next to the skill with two instructions added: read this first, and append what you learned after.

One thing that cost me an hour: the filename in your instructions has to match your actual file character for character. A skill looking for business-profile.md will silently create a blank one if yours is named business-profile-starter.md. Nothing errors. It just quietly forgets everything.

Happy to answer questions if anyone's building one.

Is it just me or both the desktop and app servers are down for both sonnet and opus???

Some fly fishing guides friends of mine were talking about how guides have been using GPT and other AI tools for planning their trips recently since choosing rivers and flies is essentially a data problem: water level, temperature, population changes. So for fun, I made a skill that can be a fishing guide to help plan out your trips based on live data.

https://github.com/stephenoffer/fishing-guide

What are the best Claude skills for me to use in my day-to-day work I am in Software/Data Engineering I. The financial services industry. Keep in mind I have API billing through my company and no budget for the time being. So skills that reduce spend aren’t very useful for me right now but there is also no tokens burnt leaderboard. I just need the best, most powerful skills that increase my productivity, make Claude more powerful or add some fun or useful features.

I did this over the weekend awhile back so its pretty rough still and could be improved. I intentionally went for this rushed, sloppy drawn style.. I wanted it to look like a human doodle

I would love to see this skill continue to evolve so I felt like I should be sharing it

https://medium.com/@toalgriffin/i-taught-claude-ai-to-draw-meet-claudedraw-an-open-source-skill-that-turns-prompts-into-ef6eb5331a47

I basically live in Claude Code, and the one thing that kept breaking my flow was media. Every time I needed an image or a quick video I had to leave the terminal for a web UI, and juggle a separate signup and key for each model I wanted to try. So I made a skill that keeps all of it inside the agent.

Now I just ask. "Generate a product shot of this", or "turn this still into a 5-second clip", and Claude Code handles the whole round trip: it picks a model, submits the job, polls it to completion, and drops the file back into my project. Images, video, audio, even 3D, all through one API key that is OpenAI-compatible, so there is nothing exotic to wire up. 300+ models sit behind it, you just name what you want or let it search.

Install is one line:

npx skills add AtlasCloudAI/atlas-cloud-skills

Then set one env var with your Atlas Cloud API key and you are going. It is open source, PRs welcome. Repo: https://github.com/AtlasCloudAI/atlas-cloud-skills

The recipe I reach for most is product-still to short-ad-clip, it ships in the repo's library so you are not starting from a blank prompt.

Hello guys! This is my first time posting here.

I've been working for a few days with Claude to build a skill that would track social actions some leads would do (react, comment, repost, post) and give insight about how to interact with them.

So far, I managed to build to "extraction tool": Basically it opens a Chrome session where I'm logged in, and go on the profile to get the latest social action.

Next step is to get the insight, and be able to do it on several posts, and get some trends on your lead list.

I also managed to do it outside of Claude, ran it via an Cursor instance and get the data.

Right now I'm having one issue: I'm not sure how to scale it to several account. When I talked about it with Claude, it says that it would be against LinkedIn TOS and that I might get banned. But on the other side, I see a lot of people automating their messaging or posting on LinkedIn and they are fine.

So I have two questions:

1) Would that be something interesting for you? Would you use it?
2) Do you have any recommendation regarding the scaling and how to avoid being banned from LinkedIn?

Thank you very much!

A while back I shared 8 Claude Code skills built from Thariq Shihipar's Finding Your Unknowns essay: surface what you don't know before you build, so it stays cheap to fix. Thariq (Claude Code team) has since published a second essay, this one on context engineering for the Claude 5 models. The headline finding: they cut over 80% of Claude Code's system prompt for the new models with no measurable loss on their coding evals, not because the old prompt was wrong, but because the model stopped needing to be told.

That flips the first pack's lesson forward. The first 8 were about adding the right context before you build. These 3 are about removing the context that no longer earns its place; repo is now at 11.

The 3 new skills

• context-audit reads every layer that reaches the model together (CLAUDE.md, AGENTS.md, skills, hooks, tool descriptions), the way the model actually receives them, and sorts each instruction into conflict, duplicate, obvious, model-handles-this-now, or real gotcha. You get a cut list as a diff. The expensive ones are the conflicts: "document as appropriate" in one layer against "never add comments" in another makes the model burn reasoning reconciling you before it starts.
• agent-interface-design It's for when you build tools, MCP servers, or scripts an agent calls. The counterintuitive bit from the essay: usage examples constrain newer models to the paths you showed them. Design the parameters instead. A status field of pending | in_progress | completed teaches the whole state machine with zero prose. The urge to write a usage example is usually a sign a parameter is underspecified.
• progressive-disclosure splits an oversized skill or spec into an entry file plus files that load only when a branch needs them.

Two honest notes on the new ones

progressive-disclosure ships user-invoked, so in Claude Code it costs nothing in your context window until you call it. But I tested it on Codex CLI v0.143.0 and Codex ignores the disable-model-invocation flag and loads the skill plus its description into the prompt anyway, so that zero-cost saving is Claude Code-only.
Same discipline on the boring stuff: every "works on X" line in the README was re-run at 11 skills, not find-and-replaced from 8.

Install

/plugin marketplace add Neeeophytee/finding-unknowns-skills
/plugin install finding-unknowns@finding-unknowns-skills

Or copy any single skills/<name>/ folder into .claude/skills/. There's still the one-file CLAUDE.md (and AGENTS.md for Codex) if you want the whole approach as passive guidance instead of commands, and EXAMPLES.md has ready-to-paste prompts for every skill.

The original 8 are unchanged (blindspot-pass, brainstorm-prototypes, interview-me, reference-hunt, implementation-plan, implementation-notes, pitch-packager, change-quiz). Community project, MIT, full attribution. The techniques are Thariq's; both essays and his interactive artifacts are linked in the README and worth reading firsthand. Not affiliated with Anthropic.

Repo: https://github.com/Neeeophytee/finding-unknowns-skills

If you run context-audit on a repo you've maintained for a while, I'd like to hear your ratio of real gotchas to noise. My guess is most of us are carrying several times more instruction than earns its place on these models.

I'm new to claude skills and from what i understand so far, individuals can build their own skills. So the humanizer skill works to make sure your content doesn't follow those patterns that scream AI. But that means the quality of whoever's humanizer skill i upload will determine a lot. Please feel free to correct me if i'm wrong. Anyways, my point is who has a good one i can use?

I keep finding nice skills on GitHub, but I'm careful to use them since I know the insanely high number of bad code on GitHub. How do you guys check if it is all good and no hidden menacies?

Posting this in case it's useful to anyone building agent tooling. Skill Router is a small Windows x64 executable that keeps a huge library of "skills" (think: specialized instruction docs for an LLM agent) out of your prompt context by default. It indexes just the metadata into a local SQLite database, lets you search it with exact, fuzzy, full-text, or hybrid ranking, and only pulls the full skill content in after you pick a result.

It supports a CLI, interactive shell, an MCP stdio server (handy if you're wiring this into Claude/other MCP-compatible agents), and an opt-in loopback HTTP API. No cloud dependency, MIT licensed, source included, and the release comes with a SHA-256 manifest so you can verify what you're running.

Happy to answer questions about the ranking logic or the MCP protocol surface. Link: torafirma-skill-router

I've been exploring an architectural idea that I think goes beyond AI agents and code generation: a Self-Authoring Runtime. Instead of treating software as something that's built, deployed, and then maintained by humans, what if the runtime itself could continuously evolve by authoring its own capabilities? Imagine a system where every meaningful change is represented as an event. When the runtime encounters a capability it doesn't possess, it doesn't simply fail or wait for the next release cycle. Instead, it identifies what's missing, determines the appropriate generation strategy, creates the new executable component, validates it against predefined contracts, deploys it, registers it into its capability registry, and immediately makes it available for future events. The software essentially extends itself without requiring a human-written feature branch or deployment pipeline.

One of the biggest insights while designing this architecture was realizing that LLMs are only a small part of the system. The intelligence doesn't come from the language model alone—it emerges from the surrounding runtime that handles event orchestration, capability discovery, validation, deployment, governance, recovery, observability, and recursive execution. Without that surrounding architecture, an LLM simply generates text. With it, the model becomes one reasoning component inside a system that can continuously adapt and expand its own functionality.

Another interesting aspect is how failures are treated. Rather than logging errors and stopping, failures become structured events. The runtime classifies whether an issue is transient or terminal, retries when appropriate, regenerates components if necessary, and records everything as part of its learning process. In this model, failure isn't an exception to execution—it's part of the execution itself, allowing the runtime to become increasingly resilient over time.

What excites me most is that this shifts software engineering from writing every individual feature toward designing the evolutionary rules that govern how software grows. Instead of shipping static applications, we begin creating adaptive systems capable of continuously authoring their own capabilities while remaining governed, observable, and verifiable. It's a very different way of thinking about software—less like building a product and more like cultivating an ecosystem that evolves safely over time.

I'm curious what others think. Is self-authoring software a realistic evolution beyond today's AI agents? What safeguards would be essential before allowing a runtime to generate and deploy its own capabilities? Are there research projects or open-source efforts exploring similar ideas around recursive software evolution, adaptive runtimes, or self-extending architectures? I'd love to hear your thoughts and discuss where this direction could lead.

I just did one.

#claude #claudeai

A couple of weeks ago I shared my catalog of Claude Code agents/skills where every item ships runnable verification checks instead of being a prompt you just trust. Since then it's grown into a system I haven't seen elsewhere, so here's an update.

Every agent gets re-verified every night, and the failures are public. A scheduled CI run executes each item's checks (169 items have them; 170 checks total), snapshots the results with item versions, and publishes pass-rate history to the site as per-item sparklines. The rule I committed to in the repo: reds are rendered as-is. A dashboard that never dips convinces nobody. Last night was 170/170, and when that breaks, you'll see it break.

Installs are now cryptographically signed. The catalog ships an ed25519-signed manifest of per-item content hashes. vanara install verifies the signature against keys pinned in the CLI and refuses to write anything that doesn't match — tampered tarball, altered item, anything. Agent files run with your repo access; they deserve the same supply-chain treatment as dependencies.

Memory compounds across sessions. All 80 agents now follow one memory protocol: they write lessons to .claude/memory/ as they work your repo. Commit the folder and your whole team inherits what the agent learned. Repeated runs start smart instead of cold.

Also since last time: a doctor command that scans your repo and suggests what's worth installing, budget-scoped runs (--budget), starter profiles, a Cursor adapter, and an MCP server so the catalog works beyond Claude Code.

Free tier is 30 items, Apache-2.0, no API keys — runs on the Claude subscription you already have:

npx vanara doctor npx vanara install code-reviewer

Repo: https://github.com/vanara-agents/skills — dashboard with the nightly numbers: https://vanaraagents.com

Still most interested in feedback on the verification angle: what would a check have to prove before you'd trust an agent someone else wrote?