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.

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 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. 🙂

Every time I asked Claude for a website I got the same thing: centered hero, three feature cards, a gradient. So I wrote **impresario**, a free, open-source skill that pushes the agent to come up with a concept before it writes any code.

**What it does**

- You give it one sentence, e.g. "make a website for a night-shift bakery".

- It invents a concept specific to that subject, then builds a flagship scene first, before it fills out the rest of the site.

- Motion is choreographed with GSAP, WebGL and SVG, with no stock assets.

- It screenshots desktop, phone and reduced-motion views in headless Chrome, then reviews and revises its own work.

- Accessibility is required: it handles reduced motion and keyboard navigation.

**Demos:** https://shushant17711.github.io/impresario/

**Repo (MIT):** https://github.com/Shushant17711/impresario

**Install**

git clone https://github.com/Shushant17711/impresario ~/.claude/skills/impresario

Then just ask Claude Code for a website and the skill kicks in on its own.

I built it with Claude Code and iterated on it with evals in the repo. I'd love feedback, especially prompts where it still comes out generic. Those are the cases I want to fix.

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!

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! 🙌

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!

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?

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.

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.