A few weeks ago I shared a free Claude Code skill for building clean, honest dashboards. Thanks for all the feedback, it got way more attention than I expected.

Then I used it on a real project: the home dashboard of a school management system. The result was honest. Every number agreed with every other number, the QA pass checked 18 cross-totals. And I hated it.

It was a page of sentences. A line under every KPI explaining the number. A row of "insights" written as sentences. A note under every chart. It read like a report, and a school director doesn't read, they scan. The worst part: those were my skill's own rules ("one muted sub-line that explains the number", "an insights line of plain sentences").

So I went back to the sources:

• Stephen Few: Information Dashboard Design's 13 mistakes, his papers on colour rules and the bullet graph spec
• Tufte: data-ink, sparklines
• Cleveland & McGill via Nielsen Norman Group: which encodings people actually read accurately
• Datawrapper on sequential vs diverging vs classed colour scales
• Six of Apple's WWDC sessions on charts, chart accessibility and interface writing
• A dashboard designer whose work I admire, for how a page can say everything with numbers and shapes

What changed in v2

• Wordless: names, numbers, units and a one-word baseline ("▼ 15% vs Sep") on screen. Every explanation goes in a tooltip. The QA pass now counts sentences. Target: zero.
• Monitor: overview → what needs attention → closer look → act. Problems are flagged on the data itself, and the action sits on the flag (a "not marked yet" heatmap cell is the remind button).
• Inverted salience: a plain light-to-dark heatmap makes the worst cell the palest when low is bad. v2 uses classed tiers where intensity grows toward the problem, plus a non-colour cue for colour-blind readers.
• New components: heatmap, bullet graph (Few's spec, replaces gauges), segmented share bar, one tooltip system.
• New QA: a salience test ("where does the eye land first?"), real messy data, colour-blindness emulation, plus the old "known totals" check.
• A case study of the school dashboard in three versions, including the one I rejected.

How I tested it

I gave a fresh agent only the new skill and asked it to build a dashboard for ad buyers running Meta/Google campaigns for several clients (screenshots above, fake data, UI in Uzbek). It came back with a clean page: CPL heatmap per client per day, budget runway as bullet graphs, problems in amber, 0 sentences, all totals checked.

It also found real flaws in the skill: a contrast bug in my own heatmap snippet (accent text on accent tint, 3.1:1), two layout rules that contradicted each other, no rule for "neutral" metrics like spend. All fixed before release.

Install

/plugin marketplace add abdiraimov-otabek/dashboard-design-skill
/plugin install dashboard-design@dashboard-design-skill

Already installed? Run /plugin marketplace update dashboard-design-skill

Repo (MIT, free): https://github.com/abdiraimov-otabek/dashboard-design-skill

Works with SwiftUI too. Happy to hear where it breaks for you.

If I had to create agents or sub-agents how do I do it. And when would I know if I have to create and agent or sub-agent.

If I had to create a whole team of agents, lets say a software team a product management team. A team to help in content and marketing just for an example how would that go?

I have tried it and told claude to do it from time to time, but never end up using it cause the output or the specification dont match. I feel like something is wrong in the way I am doing things. Any advice or insight would be appreciated. Thanks

A few weeks ago, I started experimenting with Claude Code to see if I could create high-quality animated explainer videos without touching After Effects.

I’m a web designer, not a motion designer, so this was mostly an experiment.

Fast forward a few weeks, and my last 10 videos have reached over 2.6 million views across Instagram and TikTok.

I decided to turn my workflow into reusable Claude skills, and I’m sharing one of them for free.
It’s called Rays, and it turns a simple topic into a fully animated vertical explainer video.

Here’s how it works:
1. Give Claude a topic you want to explain.
2. Claude writes the script and storyboard.
It builds and animates the scenes using code.
3. Everything renders locally into a 1080×1920 MP4.
4. The skill includes a SKILL.md, visual references, reusable animation scripts, and a working example.
5. No video-generation API keys required. Just Claude Code and the local rendering dependencies.

Free skill: https://supply.madebyoversight.com/videos/rays

I’m still experimenting with different styles, but I figured this might be useful for anyone interested in code-generated motion graphics.
Would love to see what you guys make with it!

A couple of months ago I posted about running five model families through Claude Code on ordinary subscriptions. I also mentioned it drastically saves my Claude usage + much much more… This is what changed since, and what it's done ;

• Recent Results : Since that post the system found, triaged and got paid for a second critical-severity vulnerability. That's two paid criticals now, plus the two production client sites it already ran. Still my daily driver, not a demo.

• Models : added grok and removed Kimi, Now : Claude, Codex, Gemini (through Google's agy CLI) and Grok. Kimi is gone; it wasn't being used. Claude, Codex and Gemini still run on the subscriptions you already pay for. Grok is the one exception and needs an xAI API key. For security work the specialists lean on Mythos and Opus on the Claude side and Daybreak on the Codex side.

The routing is interchangeable. Every specialist is bound to a model in one file, with a backup from a different family and a review route. My defaults come from benchmarks and from what actually did the job best in use, but if you'd rather use something else, you just ask the coordinator to swap the model for that specialist. No code.

• How it works, unchanged at the core : A coordinator runs as a Claude Code session. You describe a task in plain English, it writes a Markdown task file (which specialist, which model, what files it may touch, what counts as done), and hands it to a freshly spawned CLI in its own git worktree. 71 specialists: ordinary ones like backend-engineer and code-reviewer, and less ordinary ones like experimental-attacker, red-team-operator, reverse-engineer, threat-modeler, impact-validator, and a skeptic whose whole job is to argue with the others. Media roles still come online if you hook up ElevenLabs and Higgsfield.

• Improved focus on long tasks : This was my biggest problem: over a long session the coordinator would drift, or forget what it owed me. Three things fixed it. A hook re-anchors the coordinator on the active task every single turn and refuses to dispatch work when it has lost the thread. Every piece of work has a one-page charter: the ask, every mid-session request I raise (folded in, queued, or dropped), and the test for "done". And a board carries unfinished work across sessions, so something raised on Tuesday gets picked up Wednesday instead of dying with the chat.

• Security work : Bounty mode confirms what's in scope before testing, reproduces the impact, and runs controls to rule out false positives before anything is called a finding. Semgrep and Slither run as plain CLIs. Research now runs across three provider families in parallel, then gets synthesized and source-checked.

• Review : A reviewer from a different model family, read-only: it can pass or block, it can't rewrite. It's mandatory when a change trips one of the risk triggers; otherwise the coordinator verifies and closes. A REJECT is a useful result, not a failed run.

• Gates :Deleting files, changing credentials, touching production, publishing, outreach: refused before a worker even starts, and deletion is refused again at merge unless an exact pre-approved file list allows it.

• It remembers : What a run learns is written to private Markdown outside the repo and read back before the next run. Notes carry where they came from; a newer note doesn't silently win.

• Honest limits : macOS only for now. You need tmux, fswatch, jq, Python 3.13, uv, and the vendor CLIs signed in. Workers run on your machine with your permissions; the write scope is enforced at merge, not while the worker runs, so treat it as an autonomy tool, not a sandbox.

Repo (MIT): https://github.com/mtarcure/claude-vibe-squad

A live board, seven specialists running in parallel: [https://github.com/mtarcure/claude-vibe-squad/raw/main/assets/demo/phase3-swarm.gif\](https://github.com/mtarcure/claude-vibe-squad/raw/main/assets/demo/phase3-swarm.gif)

Disclosure : I built this. It’s free. Open source, MIT, Python and Bash, Markdown all the way down. v2.0.0 went out today.

Happy to have holes poked in it. 🙂

Tired of seeing huge cache read/write numbers in ccusage? 👀

Meet Cctoken-saverr , a lightweight skill to help manage /clear, /compact, context usage, and cache costs.

🚀 Give it a try, share your results, and let's discuss what actually works! Contributions, suggestions, and open discussions are welcome.

GitHub: https://github.com/V-inaya-K/cctoken-saverr

The old friction hasn’t gone anywhere.

I’m a performance marketer and social media marketer working with multiple clients, and I’m trying to automate as much of my daily work as possible using Claude.

I want to understand what can realistically be automated, what tools are needed, and how much the whole setup would cost per month.

Some tasks I’m looking to automate:

Meta Ads and Google Ads performance analysis and daily reports

Campaign monitoring and identifying issues or unusual performance changes

Social media content ideas, calendars, captions, and creative briefs

Ad copy and creative generation

Client updates and weekly/monthly summaries

Competitor research and marketing trend analysis

Task planning and reminders across multiple clients
Connecting tools like Google Sheets, Google Drive, and CRM platforms

Any repetitive work that I’m probably wasting time doing manually

I already use AI for some of my work, but I want to go beyond just writing prompts and generating content.

Ideally, I want a proper workflow where different tasks happen automatically with minimal manual intervention.

**A few questions:**

What can Claude actually automate on its own, and where do I need other tools or integrations?

Which features, plugins, MCP servers, or automation platforms should I look into?

What would a realistic monthly cost be to automate most of this across multiple clients?

Is Claude Pro enough, or would I need a higher plan or API usage?

If you’ve already built something similar, what does your workflow look like, and how much time does it save?

I’m looking for practical, real-world advice from people who have actually implemented these workflows — not just a list of AI tools.

Thanks! 🙌

Every new session picked up the rules from CLAUDE.md, but not what the last session found broken, left half done, or needed to ask me. I'd re-brief or drag various gitignore'd files around to carry state.

So I built symbion: a notebook and ticket registry that lives in a git repo beside the project. The video shows the loop:

1. At session start, a hook hands the agent what is open: bugs, tasks, its unanswered questions, anything due.
2. It works them, and resolves a bug against the commit that fixed it.
3. When it needs a call from me, it files a question with options. I answer with one click in the browser, or from the terminal, and the next session acts on the answer.
4. /symbion wrap ends the session with a commit whose message is the next session's handoff.

A test result also knows its age. A check records what ran, what it said and the commit it ran at, so a week later it reads behind 12, not "tests pass".

Live demo of the browser view (read-only, a real project's notebook): https://symbion.nullphase.net/

Repo, free and MIT: https://github.com/phreakocious/symbion

How Claude helped: Claude Code wrote most of the code, with me directing and reviewing. symbion has tracked its own development since September: Claude files its bugs, tasks and test runs in it, and asks me its questions there. Before each release, fresh Claude agents read the whole diff for anything that should not go public.

It also works with Codex and Hermes Agent. No MCP server and no account: a CLI, a skill file and two hooks.

How do you carry a session's unanswered questions over to the next one?

Hey r/claudeskills ,

I've been spending a lot of time working with Opus, and while its reasoning capabilities are incredible, I wanted a more streamlined way to tweak, optimize, and control its behavior on the fly. So, I built a custom tool to solve this, and I’m open-sourcing it for the community today.

Meet Opus Tuner

What does it do? Opus Tuner is a dedicated Claude skill designed to give you granular control over how Opus interprets prompts and generates responses. Whether you are using it for complex coding workflows, creative writing, or heavy data analysis, this skill helps you dial in the exact tone, formatting, and reasoning depth you need—without having to manually wrestle with massive system prompts every single time.

Key Features:

• Dynamic Behavior Tuning: Quickly adjust Opus's constraints, output style, and parameters to match your current task.
• Prompt Optimization: Helps structure and refine your instructions so Opus understands exactly what you want on the first try.
• Lightweight Integration: Built to be a simple, plug-and-play skill for your existing Claude environments and agent workflows.
• Fully Open Source: 100% customizable so you can fork it and adapt the code to fit your specific local dev setups.

Where to get it: You can check out the source code, read the setup instructions, and grab the repo here: 🔗github.com/YahyaLendani/opus-tuner-claude-skill

I’m actively developing this and would love to get your thoughts. If you end up testing it out, let me know what features or integrations you’d like to see added next. Feedback, pull requests, and GitHub stars ⭐ are highly appreciated!

Let me know if you have any questions or setup issues in the comments!

work with structured products. When I asked Claude to “price this autocallable”, it would write a new Monte Carlo script every time. Then came the run → error → fix loop, and two runs of the same trade could give different code and different numbers. That’s not usable for anything a risk or model validation team has to sign off on.

So I built Structured Derivative Pricer, a skill that never generates pricing code. The components are already built and tested on top of QuantLib: curves, models, calibration, schedules, market conventions, Monte Carlo, Longstaff-Schwartz and so on. Claude’s only job is to read the term sheet and assemble those components into one YAML file. The engine validates the whole spec, reports every error at once, shows the plan (closed form or MC, and why) and then prices.

Install

/plugin marketplace add kuanHungWang/financial_engineering_skill
/plugin install financial-engineering@financial-engineering-skill

It also works as a plain skill folder (~/.claude/skills/) or through npx skills add kuanHungWang/financial_engineering_skill for other agents. On first use it sets up its own Python venv with QuantLib.

What it covers

• Asset classes: equity (single or correlated baskets) and rates (term rates, CMS, SOFR-style overnight)
• Models: Black-Scholes (constant, term or Dupire local vol), Heston (given or calibrated to the vol surface), Hull-White 1F (calibrated to ATM swaptions)
• Payoffs: fixed and floating legs (in arrears, compounded with lockout, caps/floors), range accruals, worst-of / best-of, and path-dependent legs with carried state (snowball, memory/phoenix coupon, ratchet, cliquet, lookback)
• Early termination: autocall knock-out, TARN, Bermudan issuer call / holder put via Longstaff-Schwartz
• 15+ worked examples: phoenix memory autocall, callable snowball, CMS spread range accrual, inverse floater TARN, cancellable swap and more

What you get back besides a price

The output is meant to be something a reviewer can check:

• MC standard error and confidence interval, PV per leg, and knock-in / autocall / exercise probabilities
• a cross-check against a closed form where one applies, a martingale check of the simulated forward, and the Bermudan in-sample vs out-of-sample gap
• price.py inspect re-prices with the same seed and dumps every intermediate (paths, fixings, cashflows, discount factors, regression coefficients) to CSV/JSON
• report.py evidence runs convergence, seed stability, sensitivity, stress and benchmark tests. Claude then writes a model validation report (SR 11-7 outline by default, or your own template), with every number copied from the evidence and none computed by the model
• the engine can be exported into your project so the model re-prices without AI, with pinned versions and baseline-verify checks

How I built it

I built it with Claude Code over about 4 weeks (53 commits, all through PRs). What I learned:

• The key design decision was “Claude picks and wires components, never writes math.” Pricing quality now depends on the tested engine, not on what the model writes that day. The skill has a test suite of around 190 tests.
• The SKILL.md tells Claude to ask instead of guess on ambiguous terms (barrier observation frequency, who holds the call right, fixing conventions). It also tells Claude to refuse unsupported products (FX/quanto, equity + stochastic-rate hybrids, American exercise) rather than approximate them quietly.
• It never makes up market data. Mock data exists for demos and is always labelled as mock.

Price: free and open source (Apache).

Repo: https://github.com/kuanHungWang/financial_engineering_skill

It’s a model, not investment advice. Validate against your own controls. I’d especially like feedback from people in quant, risk or model validation on which products or checks you’d want next.

Say you give Claude a skill for editing your posts. It has instructions about your voice, words to avoid, what to cut. All useful when you're editing a post.

Then you switch to coding in the same chat and it starts applying those rules to code comments. Or you ask it to quote something and it ‘improves’ the wording. Why is the writing skill even involved in that lol.

Where are you fixing this? The short description that tells Claude when to load the skill, or instructions inside it saying when to stop?

If you've made this behave, I'd like to see the actual wording you changed. Especially if it still works when you switch tasks in the same conversation.

Hi everyone,

i've been working on a harness for Claude Code and I'm sharing it here because i'd really like your feedback.

https://github.com/habibafaisal/falcon

I recently worked on a fintech project where money movement was critical. Simultaneously I was managing product direction, user experience, backend and third party integrations. At that point, when I had the entire product laid out in front of me, it was necessary to learn the art of prioritization. I kept running into different issues, used some existing harness tools available but all of them missed a few cases.

Over time I built my own harness called Falcon (don't ask what inspired the name). It helps me put my attention where it's actually needed and balance the tradeoffs.

heres the video https://youtu.be/AUtNaEk-cLc

I've been annoyed by the dead time while Claude Code runs a turn — staring at the spinner isn't useful.

So I built Waitroom with Claude Code (and Claude in the loop for design/debug): four Claude Code plugins that run locally during that wait. No telemetry.

- wait-review — skim diffs / flag risks while it works
- bet-on-your-agent — call how the turn will go (scored after)
- wait-ship — draft commit / PR / changelog notes in the wait
- wait-breathe — optional reset between runs (off by default)

Free and open source — install from GitHub: https://github.com/coindef/waitroom

Curious what others do in that dead time — or if you've built similar hooks.

I maintain config-drift-checker, a free tool that runs eval suites for Claude Code setups (CLAUDE.md, skills, hooks) on every PR and every Claude Code release. A green suite only means something if it would go red when the setup breaks, so I built mutation testing and pointed it at my own suite.

How it works: it makes 15 sabotaged copies of the setup (delete a rule, invert a rule, blur the skill's trigger description, drop the skill, disable the hook), runs the cases that should notice each one, and counts how many go red.

Result: 6 of 15 caught. The misses were the interesting part. Deleting "use constructor injection" or "validate request bodies" changed nothing, because Sonnet does both by default. So a missed sabotage means one of two things: the graders are too loose, or the rule isn't pulling its weight. Deleting the response-wrapper or pagination rules was caught immediately.

Report: https://jameskomo.github.io/config-drift-checker/mutation/report.html

Four other things I measured:

1. Trigger map. 25 prompts in and out of scope, one-turn sessions on Haiku, $0.04. My Spring skill fires on 71% of the prompts it should take and on 30% it shouldn't, with 95% ranges. One passing trigger test had been telling me "it works". https://jameskomo.github.io/config-drift-checker/triggers/report.html
2. Model and version matrix. Sonnet and Haiku on Claude Code 2.1.296 and 2.1.310, $0.73. Sonnet held everywhere. Haiku missed one case on 2.1.310 (one run per cell, so a lead, not proof). https://jameskomo.github.io/config-drift-checker/matrix/report.html
3. Same suite, three agents. 54 runs: Claude Code 1.00, Gemini CLI 0.77, Codex 0.63. CLAUDE.md rules travel through AGENTS.md and GEMINI.md reasonably well. Hooks don't run at all in the other CLIs, so if your safety depends on a hook, it only protects you on Claude Code. https://jameskomo.github.io/config-drift-checker/agents/
4. PSA if you run evals in GitHub Actions: on Claude Code 2.1.310, claude plugin eval refused every Bash-granting run on GitHub's ubuntu-24.04 runners ("cannot confine it, no sandbox backend"), even with bubblewrap installed. Ubuntu 24.04 blocks unprivileged user namespaces through AppArmor. Fix on a throwaway runner: sudo sysctl -w kernel.apparmor_restrict_unprivileged_userns=0 (Claude Code's own error message suggests it). My release canary caught it, but my fallback runner kept the check green, which hid it for a day. Reports now say when that happens.

Repo (free to use, source-available, zero dependencies): https://github.com/jameskomo/config-drift-checker

Built with Claude Code, which also ran most of this work as parallel sub-agents. Happy to answer questions, especially if you want to try mutation testing on your own suite.

Open source!!!!

Hi I just got claude pro for one month but I don't know how to build something meaningful as i am tech student in 2nd year I don't know much about tech yet .

I just wanted to know: What Claude skills or agents are you using for designing and building ? What are tips to get good output from Claude? Give me some unique ideas for website

Give me complete Guide please !!!

New to Claude and ai. But I’m sick and tired every year having to remember my home and car insurance, broadband renewal, phone contract, gas and electric. How would I go about out getting Claude to helps me with this? Is it something I can do in chat or would code be better suited?

any commands that would help?

appreciate it.

I built an open-source skill for Claude that helps write and review product language in real interfaces:

https://github.com/RicardoGurrola15/adaptive-product-language

The problem is that an agent can build a functional screen while producing copy that is generic, robotic or disconnected from the actual product.

The skill helps with:

- landing pages

- onboarding

- login and registration

- forms

- pricing and paywalls

- CTAs

- errors and recovery

- loading, empty and success states

- bilingual interfaces

- product copy audits

It uses project context such as:

- what the product does

- who it is for

- the domain and market

- supported features

- pricing and limits

- approved terminology

- locale and tone

It has separate modules for:

- compose

- improve

- audit

- remediate

- localize

- context

The main principle is simple:

> Text without context is erratic.

It should help Claude adapt the language to the product instead of making every interface sound like the same template. It also checks for unsupported claims, ambiguous CTAs, literal translations and wording that does not match the actual product behavior.

The skill is primarily intended for Claude, but the repository uses portable Markdown-based instructions and can also be adapted to other agent hosts such as Codex or Gemini.

Early tests are preliminary:

- Gemini 3.8 Flash: 2,912 baseline UTF-8 output bytes vs 2,663 with the skill

- Claude Sonnet 4.6 Thinking: 3,289 baseline bytes vs 3,034 with the skill

- Codex contextual pilot: baseline and skill both scored 3.89/4

These are small samples. The byte measurements are not token savings, and the Codex result did not show an improvement. I am not claiming that the skill always produces better copy.

I am especially interested in feedback from people using Claude skills in real projects:

- Does the context layer feel useful or too heavy?

- Which product surfaces should be tested first?

- How should unsupported claims be evaluated?

- How can the skill stay adaptive without making every product sound alike?

- What failure cases should be added?

The attached image shows the preliminary output-byte observations. The repository includes the full skill, context template, references, examples and benchmark documentation.