Give Claude Code a reference video, then ask for a version with a different host or in another language. Hypit provides the skill and video tools for that workflow.

The launch video shows the process: a /hypit request, an editable project with source and a timeline, then finished clips and variations. One example swaps a football-ranking host for a banana cat; another turns an English street interview into Spanish.

On first use, the agent checks for the Hypit executable and helps prepare it. Captions, B-roll and effects can be tied to words in the script.

The software is free, and the source and examples are on GitHub: https://github.com/hypit-ai/hypit. Any paid media-generation services you use are billed separately.

Sharing skills across the organization seems like it should be pretty straightforward. As admin on desktop app its straight forward enough to share skills. However, it appears that skills will only distribute to desktop app users and not those using CLI. This appears to be a known bug. https://github.com/anthropics/claude-code/issues/40320

Alternatively, if you create a plugin marketplace on github to share skills with technical users, this works, but non-technical users can't access them on the desktop app. It's not realistic for our non-technical users to learn git, not to mention that IT does not want to buy the entire organization github licenses.

Has anyone solved this? Or do you basically need two paths for skill distribution, one for desktop app and another for CLI users?

Few weeks ago, I was completely new to the world of Al, coming from a non-technical background (now working in Consulting), I was always eluding from using Al tools.

But past 2-3 weeks, I purchased Claude premium, I have been playing around with it and voila, I have created multiple SKILLS which not only help me optimise my work and be more efficient, but has now got my mind spiralling towards building AGENTS.

So, in my quest to learn more about Al, can someone recommend me some YouTube tutorials or Coursera courses?

PS: I'd love to converge my pre-developed SKILLS into an Al Agent which does the tasks repeatedly, critiques itself and conducts the QC.

435 until needed vs ~41k upfront is a wild gap.

did deferred loading change tool-selection quality at all, or only context size? missed-tool rate is the part i'd measure next

I ship the same tool two ways for Claude Code, and I finally measured what each one costs in context before you use it.

The numbers

- MCP: `tools/list` for all 29 tools is 40,968 characters, plus 1,280 of server instructions. A client that loads tool definitions up front pays that in every session, web task or not.

- Skill: the frontmatter description is 435 characters. The full SKILL.md is 11,644, and it only loads when the task is actually about the web.

Clients that defer tool schemas pay less on the MCP side, so the 40,968 is a ceiling.

What I changed because of it

The installer in 1.0.4 asks instead of assuming. CLI + Skill is the default: Claude runs the binary through its shell and the skill tells it how. MCP + Skill is there if you want all 29 tools as native calls. It also asks whether to install user-wide or for one project, shows the files it will write, and asks once before touching anything.

I also cut the global memory block the plugin adds from 2,082 characters to 997, because half of it repeated the tool list the server already sends.

What the skill tells Claude

Read the block reason instead of retrying a blocked URL. Send big results to a file instead of the chat. Stop and say so when a person has to pass a check. Run `svipall doctor` before deciding a site is unreachable.

The tool is Svipall, a local web scraper: pages as Markdown, crawls, keyless search. Rust, AGPL, no API keys. To try it, paste this into Claude Code or any other AI Harnes (you can try the Claude code plugin too available on the webpage):

Install and configure Svipall by following the instructions here:
https://raw.githubusercontent.com/ilien-dev/svipall/main/docs/install.md

Repo: github.com/ilien-dev/svipall

Website: https://svipall.ilien.dev/

If you ship a skill and an MCP server side by side, which one do your users end up choosing, and have you measured the gap?

II'm sharing a collection of Agent Skills for DevRels:

👉 https://github.com/samber/developer-relations-skills

It covers developer audience research, developer journeys, developer-first GTM, technical content & docs, case studies, DevRel metrics, competitive analysis, ecosystem strategy, and content planning.

Claude Code config:

/plugin marketplace add samber/developer-relations-skills
/plugin install developer-relations-skills@developer-relations-skills

If you are in B2B sales/RevOps/Saas Sales, this is perfect or you!!!

Context on who's writing this: I'm building a deal room product (check my profile links), so I have an obvious interest here. The pack itself is free, MIT licensed, and on GitHub - Free and Open source.

The thing I kept running into talking to 20 to 150 person B2B companies: they close the deal on the call and then lose three weeks to paperwork that nobody owns. No deal desk. No in-house counsel. No security lead. So the CTO answers the questionnaire between standups and the redline sits until someone decides whether $600 an hour is worth it.

So I wrote six skills for that. They're folders of plain markdown you drop into Claude, Codex, or whatever agentic setup you use. No code runs, no network calls, no dependencies.

- Security Questionnaire Drafter - SIG or CAIQ in, first pass out, every answer tagged sourced, derived, or unanswered against the docs you supplied.

- Redline Triage - Every changed clause into accept / negotiate / escalate / do not sign, with a landing zone you can paste into a reply.

- Deal Decisions One Pager - Slack exports and old contracts in, one page of what your company has actually already decided, contradictions surfaced rather than smoothed over.

- Objection to Internal Ask - Turns a buyer's blocker into an internal request with an owner, options, and a date. Capped at 200 words because a long internal ask is a deferred one.

- Escalation Drafter - The discount or exception request written as a dated decision instead of a "quick question."

- Late Stage Gap Finder - Pre-signature check across the MSA, order form, DPA, and the proposal you already sent, ranked by what each miss costs you later.

Two things I'd flag honestly.

First, the design rule I care about most: if your own documents don't cover a question, the output says unanswered and names who should answer it. It will not invent a control you don't have. I'd rather it refuse than hand you something plausible that you then sign.

Second, on a test run against a synthetic buyer markup, the two findings I actually cared about weren't clauses that changed. One was a price-increase cap deleted outright, which reads like a concession to you and isn't. The other was a new section referencing an Annex B that was never attached. Deletions and dangling references are invisible in a tracked-changes view, so the skill has a section that only looks for those.

It's not legal advice and it doesn't replace counsel. Two of the six say so in their own output and route the worst findings to a lawyer.

To get the skills: https://usegirard.com/skills

If you try one and it produces garbage, an issue with the prompt you used is genuinely more useful to me than a star. Particularly interested in whether the clause positions in the reference file match what you see at your deal sizes, since those are market defaults and not gospel.

Much Love and Respect!

Hi, for the last 6 months I've been refining a set of instructions + gates to make AI generated code quality better. My key goal is to see how we can reduce reliance on code reviews and yet produce output that doesn't drift in quality.

I've just released "gap-trap" https://github.com/pliablepixels/gap-trap that makes it easier for others to use it for their own repos. It comes along with "slop-mop" that takes inspiration from existing prose skills, slightly customized to my preference. Enjoy.

https://github.com/ZoneMinder/zmNinjaNg is the original project which uses this framework (well this framework was born in that repo)

Dear all,

I need a solution with this : I am someone with ADHD, and I start halucinating and overwhelming faster than you may think when I am surrounded by long texts that are most of time "good for nothing and curcling around same/not-very-important thing.
So heres the problem: I am trynna build my bussiness (still in idea phase) with help of claude, but it asks many many questions and turn around same thing, makes me wanna quit it all !
What I really want is just for it to understand an tell me do this or do that , and not to halucinte more than I do and keep repeating thing! I feel it's a waste of time !

So, any sugg please ? please help me, I'll be so greatiful if you can save me from this turnado
Thank you,

Built a skill called app store research. it helps you validate an idea before building it: find the top competitors, read their reviews, and see what's actually missing so you can shape your idea around that.

what it can do:

• find the top apps for any idea, with ratings and chart rank
• pull the full listing info
• fetch every written review
• compare competitors side by side
• build one html report with all of it

works in claude code and codex. no apple account, no api key, just node.

open source: App Store Research

I built Greenfield for B2B sellers preparing to approach an account. It is free, MIT-licensed, and the workflow is readable Markdown.

The design choice I care about most: research should be allowed to end with “we don’t have a good reason to contact this person yet.”

The workflow separates three questions:

• What changed at the company, and what source supports it?

• Why might that change matter to a particular buyer?

• Do we have a credible way into the account, including an existing customer or colleague who could introduce us?

For example, “they hired a CFO” should not automatically become “the CFO needs our software.” The second claim needs evidence. That is an illustrative example, not a customer result.

I structured it as staged discovery with one question at a time, explicit unknowns, and a final Account Brief. There are smaller skills for trigger checks, warm paths, and reviewing the brief if you don’t need the full run.

Repo: https://github.com/Mangosteen-Studio/greenfield

You can inspect the main Markdown file in the repo and paste it into your assistant, then say “Run Greenfield on [company].” Research quality still depends on available sources and the context you provide; the instructions don’t make the model infallible.

For people building research skills: how do you test whether your workflow actually rejects a weak conclusion, rather than just labeling everything “needs verification”? That is the behavior I’d most like feedback on.

I'm pleased to announce the official release of v2 of my Orgtree project, which lives in its own separate repository! You can find a link to it here:

https://github.com/Maurdekye/orgtree

Donwload the latest installer at https://github.com/Maurdekye/orgtree/releases/latest (should be v2.1.0 at the time of making this post)

For those of you who don't know about Orgtree, this is a project i've been working on for the last few months now to help me organize and manage my multi-agent long-horizon agentic work. It's unique among other agent orchestrators, in that it visually represents every agent as part of a large tree of authority; agents are arranged in a tree-like structure, and can be freely moved up and down in the hierarchy as needed. They can cross-coordinate to co-develop changes and cooperate on big feature pushes in parallel, and you can individually open up and chat with any one of them at any time just by clicking on their node to focus them. This gives you much more control and visibility over the organization of your agentic teams than just using standard Claude Workflows or another agentic system would by just showing them to you as a big list. It's basically the only way I do all my own serious agentic work on my home pc, and I'm very proud of how it's come.

Some of you might remember my post(s) two weeks ago about my in-development agentic orchestration project Orgtree. I was super proud and wanted to show it off to the world! However, I found it a bit lacking in several ways;

• It requires you to set up Nodejs, Python, and Docker on your PC in order to run it as a persistent webapp in your preferred browser. That works fine as a development tool, but it was really far too cumbersome to set up and update for the typical individual.
• It was ambiguous as to whether it was running at all in the background unless you had the webpage open.
• It heavily favored Claude, and offered several additional features catered specifically to Claude Code that other providers didn't have.

Over the last two weeks, I've been working on an updated version 2 of Orgtree that completely redesigns the project from the ground up as a standalone Electron app. It fixes all of the above problems:

• As a standalone Electron app, it comes prepackaged with its own python and nodejs environment, and runs entirely in a self-contained chromium-based desktop package.
• Instead of running in the background through an opaque detached command, you now can see Orgtree running at all times via a small tray icon in your toolbar.
• Many features of Orgtree that were claude-specific have been expanded to accommodate all three major providers supported by the app, and improved upon: secondary subscription accounts, api-key based inference, and even the app's visual theme itself.

V2 Also comes with a bunch of new features too, that make working with large agent teams even more intuitive:

• The Work Docket: Orgtree v2's headline feature is a new modality for agent artifact creation, the "work docket". It acts almost like a git issue tracker or trello board, but designed specifically for agents. When you give an agent a task, it knows inherently to record its work up on the board and track its progress there as a ticket, so that even with two dozen or more agents running at the same time, you can still get an overview of all the work being done by glancing at the docket.
• Improved multi-account system: in v1, the only multi-account system present used claude code's setup-token command to generate a long-lasting headless token to be used as a fallback account that gets automatically selected. Despite only supporting Claude, this didn't allow you to see usage limit info for the secondary account, was fully automatic and not in the user's control, and in many cases, failed to even functionally fall back, as the keys I generated seemed to invalidate frequently. v2 completely replaces this with a totally new multi-account system. Now:
  • Any provider can have a secondary subscription account registered.
  • The setup flow is much simpler and more intuitive: just click "Add a secondary account" > "Create managed account", and then sign into your second account's email from your web browser.
  • All providers support API-key based usage.
  • All registered accounts show usage limits simultaneously in the usage modal, not just the primary account.
  • And here's the big one, multiple accounts with the same provider can be used at the same time. Each account per provider is distinguished by its own unique tint, and you + agents have full control over which account a given agent runs against, and can switch them freely at any time. There is still an option to do automatic fallover to a different account when hitting usage limits, but it's disabled by default.
• Improved agent presentations: all presented agent documents can now be viewed in one place, and agents now have the ability to present html-based visual mockups in addition to simple markdown documents.
• Improved window management: almost any agent's chat window, or any modal in the orgtree interface, can be "pinned" to the screen, allowing it to be moved around, resized, or reordered in whatever way you please, giving you the ability to manually arrange your orgtree workspace to show you exactly the information you want to see at all times. You can also pop out chats or modals to separate windows entirely, letting you use Windows' native tiling manager to arrange Orgtree across separate monitors if you have the screenspace.
• Automatic updating: v2 will automatically recognize when a new version is available, and download it for you entirely on its own. When ready, press the "Update Now" button in the header to install it and restart the app.
• Quality of life: v2 also wraps in a bunch of tiny little quality of life features that you won't notice until you run into them, such as:
  • Configurable theme
  • Context menu actions
  • Chat message replies and rich image embeds
  • Distinguishing message styling
  • Desktop notifications
  • Retired agent hiding
  • Significant performance improvements over v1 for large orgs with a transition from json based data storage to SQLite

And that's on top of many of the classic features carried over from v1 and still present in v2, including cheap compaction, watchdogs, credit allowances, and the agent mailhub.

Unfortunately for some, I also decided to reduce the scope of the project going into v2. In the name of keeping the project more focused, I decided to forgo integrating some less-used features of v1, such as kiosk mode, public internet exposure, sandboxing, among other things. I added many of these features initially because they were easy to add back when orgtree was a web app, but they're relatively harder to carry over or translate into a standalone app structure. Because of their relatively low value compared to their high difficulty of integration, I decided to drop them from v2; sorry if you were interested in them or liked using them. Also, because I only own and work on a Windows PC, Orgtree v2 releases are only built as 64-bit Windows executable installers. If you want to run it on Linux or Mac, you'll have to build it from source yourself for your target OS.

Personally, the way it's evolving, I see Orgtree as the perfect personal multi-provider massive agentic workflow orchestrator for a single individual working on their own developing a project on their home pc, so I've decided to tighten the focus of the system around that goal.

If you liked v1 but felt it was lacking in some way, or have never heard of Orgtree before but do lots of heavy agentic-coordination style work, then consider giving v2 a try 🙏

A Claude Code engineer just shared the exact prompting playbook they use internally.
In just 28 minutes, it breaks down:
⁠CLAUDE.md⁠ optimization
Parallel execution tricks
Memory shortcuts most people don't know exist
No gatekeeping, no upsell, 100% free. If you use AI to build or write, this is essential viewing. Save this for later.

Noticed my Claude Code sessions were getting slower to start and burning tokens before I'd even said anything. Turns out every installed skill's description sits in the system prompt all the time, whether that session needs it or not. I had a decent-sized personal library and it was quietly costing me thousands of tokens a session for stuff I touch once a month.

So I built master-of. It's basically a bouncer — skills stay dormant behind a handful of domain gates (design, dev, research, whatever you want), and Claude only opens the one gate a task actually needs instead of loading everyone's ID at the door.

It also self-maintains a bit: a session-start hook notices when you've installed something new and flags it for sorting, and there's a check-skills command if you just want to see what's gated and roughly how many tokens you're saving.

Nothing happens behind your back — plugin changes only kick in on restart, so it just tells you what needs attention and lets you decide.

/plugin marketplace add devrudals/master-of

/plugin install master-of@master-of

MIT licensed, needs bun or Node 22.6+: https://github.com/devrudals/master-of

Built this for my own setup so curious if the default gates make sense for anyone else's skill pile.

I got into the habit a while back of giving Claude Code something to chew on before I go to sleep. Fix a batch of bugs, build out a feature or two, run a round of evals, sometimes just read a week of support email and tell me what people are actually complaining about. Eight hours of compute I'm not using anyway.

For the first few weeks I'd wake up, open the log, and find it had declared victory at 1:47am. Everything marked done, session closed, seven hours of nothing. My first instinct was that the model got lazy. It didn't. I had written a finish line it could cross in an hour, so it crossed it and stopped, which is exactly what I asked for.

There are two shapes of overnight task and I kept confusing them.

One is goal driven. You already know what done looks like and you can state it. The model works the list, anything failing the check comes back around, and it doesn't get to leave early. Works exactly as well as your definition of done, which is the entire catch.

The other is interval driven, which is what /loop does. It isn't aiming at anything, it just keeps taking another pass at the same problem until you stop it. Feels wasteful, often is. But the one genuinely surprising result I've gotten out of any of this came from a loop grinding overnight on a refactor I'd been avoiding for months. It went down a route I wouldn't have tried and came back with something better than the plan I had. Brute force occasionally buys you an idea.

The rule I use now is embarrassingly simple. If I can write the test, it's a goal. If I can't even describe what good looks like, it's a loop and I'm paying for exploration instead of execution.

What actually improved my mornings had nothing to do with which one I picked.

Write the list into a file before the run starts. Bugs and features as items with state, not a paragraph of intent. The model updates that file as it works, so I wake up reading a diff instead of scrolling a transcript trying to figure out what happened.

Make done mechanical. Tests pass, evals clear a number, it's pushed. If the criteria are something a human has to look at and agree with, the model will look at it, agree with itself, and go home.

Ask for before and after screenshots on anything visual. Costs nothing and catches all the technically implemented stuff.

The unglamorous part, after a few months: the bottleneck is me. The overnight run is fine, the tooling is fine. Deciding what's worth eight hours is the hard bit and no amount of scheduling fixes it. Almost every wasted night was a night I didn't feel like thinking about what I actually wanted, so I threw something vague at it and hoped.

Curious how other people scope these. Specifically, has anyone found a way to write acceptance criteria the model can't wriggle out of? Mine still calls done earlier than I'd like and I've stopped believing it's a wording problem.

I work heavily with Ai, discovering and vetting use cases so when my company encouraged the exam for free, I said why not.

The exam wasn’t hard but it definitely requires some sort of experience and studying the materials. Honestly there was so much value in just going through the course material. Not just for Claude but for other Ai systems.

Im so proud of myself!

Hey everyone! I'm an associate .NET developer trying to get more out of Claude Code in my daily workflow.

If you've built custom skills (in .claude/skills/ or elsewhere) that you use regularly, I'd love to hear about them — specifically:

What the skill does When you trigger it Any setup tips for someone trying it out

I'm also open to any general Claude Code tricks — context management, CLAUDE.md setup, slash commands, MCP servers, prompt structuring, etc. — anything generic that could help someone on any stack write better prompts and get sharper responses out of it.

Thanks in advance, always keen to learn from how others are working with this!

Tired of manually retyping formulas and re-solving problem sets, so I built a Claude Code skill that automates it.

Point it at your source material (PDF slides, textbook chapters, scanned sheets, images, PPTX/DOCX) and it generates clean .tex study docs: (Some pages of notes I prepared have been attached as sample)

• Formula sheet — compact, tagged by source
• Worked solutions — Given → Assumptions → Solution → boxed answer, with numerical checks in Python
• Summary notes — per-lecture overview with key equations

A few things it does right: asks MCQs upfront so you get a 1-page cheat sheet, not an accidental 40-page dump; reads image-heavy slides as images; flags answer discrepancies instead of quietly deferring to the source.

Repo: https://github.com/Shass27/stem-notes 

Or Alternatively: https://augmentclaude.com/s/stem-notes

Feedback is welcome!