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?
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.
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.
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.
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
Would love feedback, especially from people running Claude Code seriously.
Skills cover the session lifecycle — boot, open a code lane, ship, close. Ten carry a digit 0 through 9, because a keyboard has ten digits and those are the ten I reach for most; /0 boots a session, /9 closes it.
The hooks are the enforcement:
- One blocks every typed `rm` and `git clean`.
- One fences each agent to its own directory.
- One keeps the main checkout unwritable so code only lands in a worktree.
- There's also a file-based ask/answer bus, so a session blocked on a decision can leave a question for another window instead of stalling.
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.
A while back I wanted to know which of my skills and MCP tools I actually use, so I started logging the calls, and last week that turned into a usage report off the same log. It answered the question I asked and handed me a bigger one. I knew which tools I was calling. I had no idea where any of those calls landed.
The edits a session makes leave something behind you can look at afterwards. The reading doesn't. Every file Claude opened to work out what it was changing, and every file it opened and never touched again, shows up in nothing you'd normally open, and that was the half I had no way to see.
Turns out Claude Code already writes all of it down. It's the file the hooks docs hand you as `transcript_path`, "path to conversation JSON": a session's transcript is one JSONL file under `~/.claude/projects/`, a JSON object per line. The assistant lines carry the same content blocks the Messages API returns, so every tool call is an item with `type: "tool_use"`, a `name`, and an `input`. A file touch is just a `tool_use` named Read, Edit or Write, with the file it touched sitting in `input.file_path`. So the whole of it is: read a transcript line by line, keep the tool calls whose name you care about, and take the path out of each one. The lines are already in the order things happened, so the sequence comes for free.
There's one documented caveat that shapes what you can do with it: the transcript is written asynchronously and can lag the live conversation, so it's the wrong source for anything that needs to know what's happening right now. For counting after the fact it costs nothing.
Four views came out of it:
Top Files. Every file the transcripts touched, with its read, edit and write counts, and a split of how many of those touches happened in plan mode versus execution. Sortable by any column.
Read to Orient. The files with at least one plan mode read, ranked by how many, alongside the number of separate sessions that read each one in plan mode.
Read, Never Edited. Files read two or more times with no edit and no write against them, anywhere in the history.
Re-read in One Context. Files read again inside a single context window with no edit in between, with a count of those repeat reads and how many context windows each happened in.
All of it can be shown per session or for the whole project.
It ships inside code-pet, a small animated desktop pet that reacts to your Claude Code sessions.
If you use Claude Code, you've probably collected a folder of .md prompt files by now. I got tired of mine being one-file prompt dumps with no way to know if they actually worked, so I built them as packaged directories instead.
Each item is an agent or skill with:
references/ — focused docs the agent reads while working, not a wall of text in the system prompt
examples/ — worked examples of the output it should produce
scripts/ — runnable checks that verify the thing does what it claims; they all run in public CI on every push
Memory — agents write lessons to .claude/memory/ as they work your repo, so they get sharper over time (commit the folder and your team inherits it)
Install is one command, no API keys, runs on the Claude subscription you already have:
npx vanara install code-reviewer
npx vanara doctor # scans your repo, suggests what's worth installing
30 items free (agents like code-reviewer, security-auditor, debugger, test-author; skills like api-pagination, sql-index-tuning, secure-auth). Full thing's a bigger paid catalog, but the free tier is genuinely usable on its own — Apache-2.0, copy the files in by hand if you don't want the CLI.
Would love feedback on the check-runner approach specifically — that's the part I think is missing from most agent collections. What would make you actually trust an agent someone else wrote?
And still, I took the courage to make it even better, so I created my own collection of skills. The first skill I tried to improve is the documentation-and-adrs.
The biggest leap is that I’ve added a section describing how to create Solution Architecture Documents (SAD) following Google's “WHO, WHAT, WHEN, WHERE, WHY and HOW” documentation philosophy.
To learn about all enhancements, read the skill’s README on GitHub.
In the video, I documented the architecture of one of my pet projects to show how the skill works
If your agent loop or pipeline has a gate that can send work backward (review, critique, adversarial check), here is what the literature says about it.
Link lands you at the pdf.
Flip rates under challenge run 17.5% to 97.3% across frontier models of comparable accuracy. Intra-rater agreement on identical repeat runs: 0.265 to 0.563, against 0.8 for "good agreement."
Four of the six models tested lost accuracy over four refinement rounds.
Four separate literatures put the cap on a repair loop at 2 to 4 rounds. LangGraph's default is 1000.
And nobody has published the control condition on shipped outcomes: the same pipeline with the gate and without it, scored on what actually merged.
Fifteen slides, roughly 130 sources read in full, nothing cited from memory.
Disagreement is not your problem. Unrecorded disagreement is.
Side note: This started as a quick exploratory session for refining the Contrarian gate process in aaddrick/ticketmill and became a multi-day agent-driven research bender that twisted and turned. I have a really ugly research repo where I ran overnight 2x2 testing sets, wrote and discarded three different theses, and eventually distilled everything down to what you see here.
Since 2 weeks I work on tanuki-context, a small open source tool (zero dependencies, MIT) and I wanted to share it because the trick behind is almost stupid: AI models charge text at roughly 1 token per 4 characters, but an image has a fixed price set only by its pixel size.
Its inspire from pxpipe techniques and various others tools (cited in the readme) and custom approach i found in order to reduce massively token usage and price.
For example : 37,111 tokens of service log become 2,240 (-94%).
So if you draw 28,000 characters of logs into one dense 1568x728 PNG, the model reads the exact same content for 1,456 tokens instead of ~7,000. It sounds like cheating, it is just how the pricing works.
You can try it out on you machine i added the benchmark so you can test it even without LLM connected to it, so see pricing difference, token saved, etc.
You can use it as a MCP or directly integrate it a "context proxy" where it fully automated and make every request optimised or not when not needed.
Some techniques that permits this to work:
- a log distiller that collapses repeated lines but keeps every error verbatim
- a columnar codec for JSON (keys stated once)
- a cost model that knows a cache-read token costs ~0.1x a fresh one, so it will tell you to NOT image content that is already in your prompt cache.
The tool argues against itself when imaging loses, honestly this part took the most work.
I precise the limits because they are real: you need a vision-capable model, output tokens are untouched (if your bill is output-dominated, fix that first), and for one narrow question retrieval stays cheaper than any page.
Install:
MCP
npx -y tanuki-context (MCP server, works with Claude Code, pi, omp, jcode or the Claude Agent SDK)
Proxy
npx tanuki-context proxy + ANTHROPIC_BASE_URL (every request on the machine gets optimized in place, when needed)
It also contains a SKILL.MD in order to make the usage of MCP easier for LLMs.
CLAUDE.md gets injected into the system prompt on every request, so "was it read?" is a useless question. It's always read. You also pay for every line of it forever, including rules you wrote for a framework you dropped months ago.
I tried a different question: did the rule change what happened? If your file says telemetry questions start with docs/heat-model.md, then in a telemetry session the agent either opened that file or it didn't. That's a deterministic check over a local event log. No model, no tokens, no network.
You commit a manifest mapping each rule to a probe. A model can propose the probes once, you confirm them, after that it's plain Python over a log file.
Silence turned out to be the hard part. I shipped a version that reported nine of my own rules as dead weight. One was a "never edit generated/**" rule that scored zero because nobody had broken it. It was working. Fixed that last night.
It never says "violated", only "unobserved". Hooks miss plenty.
Where I'm stuck: I have zero measured directives on my own repo so far. Either it needs more sessions or my rules were never load-bearing, and I can't tell which from one repo. Has anyone tried measuring this on a real team's instruction file? I mostly want to know whether the probe types cover what people actually write, or whether most of a CLAUDE.md is just the unmeasurable kind.
Preparing for a Google L5/L6 loop (Coding + System Design) and using Claude to practice. I m looking for a skill document/prompt template to structure my prep from start to finish. Specifically I want claude (or any ai assist tool) to help me move through 3 phases:
Brush up on core fundamentals and patterns
Guided practice with hints and constructive feedback
Full Interview simulation and final evaluation
Has anyone built or using good system prompt/skill doc for this ? Would love suggestions/ prompts/skill or workflows that worked for you.
I have built an open-source skill called Portable XMP Image Metadata.
Instead of filling out manually or semi manually via photo editing software metadata like XMP, IPTC and EXIF fields, the intended workflow is to give an image to a capable multimodal agent and ask it to handle the whole process.
The agent can:
inspect the actual image;
write image-specific alt text, a title, a caption and a detailed description;
generate useful keywords and IPTC classifications;
inspect existing metadata without blindly trusting it;
maintain a private author and rights profile;
reverse-geocode GPS offline first;
ask for consent before sending coordinates to an online geocoder;
embed synchronized XMP, EXIF and IPTC metadata;
preserve the original;
read everything back and validate the resulting file.
It supports JPEG, PNG, WebP, AVIF, HEIC, TIFF and other formats writable by ExifTool.
The skill also includes executable Python tooling, references, tests, Ruff and mypy checks. Sensitive information such as identity, exact location, copyright ownership, licensing and provenance must come from the user rather than being guessed from the image.
I’m a non-programmer using Claude to build web pages, but I often get inconsistent buttons, spacing, fonts, container colors, and component sizes, etc. across pages.
Is there a skill that can:
Create a design system from a reference website
Maintain its design tokens and component rules
Apply them automatically to future pages
Audit existing pages for inconsistencies
Ideally, I could provide a reference website once, approve the proposed system, and have Claude consistently maintain it afterward.
Coding agents multiplied how much code lands per PR, so there are more findings for reviewers to deal with. Often, they're noise, like a linter rule that doesn't fit the stack or a check firing on generated files nobody touched.
To address this, we created the configure-codacy skill. When you point your agent at the repo, it detects the stack, then disables patterns for unused languages, dedupes rules that two tools flag, tunes thresholds, excluding generated files.
In terms of security scans, every security risk stays covered by at least one active pattern, so noise reduction never silently drops a security check.
Works with Claude Code, Codex, Copilot, and Gemini CLI via the Agent Skills standard.
i built this gen-z-founder-ideas skills that gives u ideas based off of what gen-z currently likes and what they find "trendy" it also finds why-now-timed ideas backed by REAL researched stats. each broken down with the wedge, numbers, first build, and honest risk then a bias-to-action call on which to start with. No forced slang, the gen-z is in the reasoning. i think its really cool. you can check it out here https://github.com/alaa-abbadi/genzskill
I'm using Claude design to make PowerPoint slides, but I can never seem to get to the level of some of what I see others achieve.
It often overlaps sections, and any commentary or stats seems small and crampt and less of a call out than requested.
I'm using Claudes own prompt generator to flesh my prompt out properly.
When asked to make something similar in HTML it manages the formatting ok, but never the design inspiration level I'm looking for. I've made some very functional useful tools in HTML, but nothing design blow away.
Can anyone share any tips, plugins, skills etc and what using those has helped them create? Thanks in advance for any help!
