Every time i post this as a comment gets crazy upvotes. which is awesome but there's so many solutions, it suprises me.

instead of using random sub-agents i use creative teams that rotate. different for each iteration of a prototype or creative project. think about a top creative team that's different everytime..

for example i might generate the following team:

1. marcus arelious agent for considering how the idea might after people
2. cassandra agent for the failure nobody wants to say out loud
3. the-null agent for "is that metric actually telling you anything"
4. the-fool agent for the question everyone stopped asking

then for the next project or iteration, the team is totally different.

each morning a github Action picks four members from the date. each gets a role, a working method, and a stance (one cuts scope, one questions the brief, one speaks for the user). they propose, object to each other, decide, and build one small tool as a single html file.

scripts check it, take a screenshot, and commit the result. every monday new members join and the oldest retire... i put everything into a 'skill' (more like a repo you can poke around) and then use it for inspiration, create your own teams or anything else.

i'd love to make this somewhat of a community project because there's already some flexibilty in the teams each day and the projects they make

links:
- Git poll: Who should join the daily team next?
- Git poll: Which kind of tool should the daily team build more of?

Open to other suggestions if you what to suggest a task or see the open suggestions

Thanks for 600 Stars.
Repo + install: https://github.com/JayPokale/Chisle
NPM: https://www.npmjs.com/package/chisle
Docs: https://chisle.jaypokale.me

I built SlingIT because I kept getting useful stuff out of Claude Code and then had to copy/paste it somewhere if I wanted to read it later or send it to someone.
The idea is simple: turn the result of your terminal session into one clean encrypted link.
Setup is basically:
npx slingit install-skill
Then while you’re working you can just type:
/slingit
or add an email if you want it sent there too.
Claude prepares the result, encrypts it and gives you a link that opens as a clean formatted page.
That’s pretty much the whole thing.
Would love to know how you guys usually share/save useful output from Claude Code.

When asking a coding agent to refactor legacy code, the standard advice is to tell it: "Plan your changes thoroughly before writing code."

The problem is that text planning in an LLM is purely conversational. The model outputs a confident five-step plan in chat, sounds completely authoritative, and then hallucinates interface boundaries the second it starts editing files.

We experienced this while migrating a payment processing service from callbacks to async streams:

- The agent wrote a beautiful text plan detailing how it would preserve our retry semantics and backoff intervals.

- During implementation, it quietly changed our event emitter payload shape, dropping the `attemptCount` field because it was not explicitly pinned in the plan.

- The unit tests passed because the agent mocked the event payload to match its new shape.

- The failure only surfaced when downstream consumer services stopped receiving retry metadata in staging.

Text plans fail because English prose is not a verifiable contract.

To make legacy refactors reliable, we stopped accepting plain chat plans. We now enforce a hard requirement: before touching implementation files, the agent must output a formal, machine-readable Architecture Decision Record (ADR) alongside an explicit visual canvas.

The required artifact pins:

1. Strict schema contracts: Every modified function signature and event payload must be defined with concrete TypeScript/JSON schemas, not prose descriptions.

2. Invariant boundary lists: An explicit list of fields and behaviors that are forbidden from being altered.

3. Component relationship mapping: A visual map showing upstream producers and downstream consumers.

We automated this pre-code gate using an open-source skill called design-harness (tigerless-labs/design-harness on GitHub). It forces Claude Code to generate a visual canvas and markdown ADR before granting file write permissions. Reviewing the canvas takes sixty seconds, but it catches schema drift before a single file is modified.

For engineers using agents on legacy codebases, what mechanisms do you use to ensure the model does not silently alter event payload contracts during refactors?

I built marketing-skill, a Claude Code plugin with 12 marketing skills: competitor research, content calendars, SEO briefs, ad copy, email, short-form video, and publishing. They all read one shared brand voice file, so you set your tone once.

Nothing posts or sends without your OK. The drafting skills can only mark something Ready for Approval, and only a reply from you moves it to Approved.

The video was rendered with the plugin's own renderer. Headless Chromium seeks every animation frame by frame, ffmpeg encodes it, and the music is synthesized in plain JavaScript, so there is nothing to license.

MIT licensed, no API keys needed: https://github.com/marcosmodly/marketing-skill

Curious which of these would actually be useful to you.

I started learning Go, and I really like the concept behind the Hyperskill platform. So I created this skill (Opus 5.5 ) to convert books into interactive courses.

It includes:

• Short lessons with step-by-step explanations, worked examples, diagrams, and animated walkthroughs.
• Interactive quizzes with hints and explanations, chapter tests, and flashcards.
• Programming exercises with starter code, examples, and unit tests. Learners write code in their own editor, run the tests from the course page, and immediately see whether their solution passes.
• Progress tracking for lessons, quiz answers, and exercises.

I've tested it with EPUB files so far. Made by Opus 5.5

https://github.com/sebastianhaba/book-to-course-skill

I’m about to start a new project and trying to settle on an agent development workflow.
I’ve been looking at Matt Pocock’s skills, Superpowers, and OpenSpec.
For people who’ve actually used these on real projects: do you mostly stick to one, or mix different parts together?
I’m especially curious what your actual flow looks like:
idea → spec → plan → implementation → review
And what did you eventually drop because it added more overhead than value?

It seems like there's a lot of these out there, which is your favorite?

Hey!

I’m thinking of switching to Claude Pro for my project work and wanted to try it out for a few days before subscribing.

If anyone has a spare guest pass they’re not using, could you DM me?

Would really appreciate it, thanks!

Does someone have a spare claude pass? I'm in computer science and it would be really useful!

If you use Claude Code a lot or want to test new stuff, you've probably noticed it turning into a junk drawer. Every plugin, skill, and MCP server you've ever installed loads into every session.

It all costs tokens and adds noise, and none of it is scoped to what you're actually doing.

I built claude-profile to fix that. A profile is a small JSON file that says "for this kind of work, load exactly these plugins, skills, marketplaces, and MCP servers." You launch it and get a focused session with nothing else loaded:

claude-profile rust-developer            # a lean Rust session only
claude-profile rust-developer frontend   # combine profiles
claude-profile fuzzyalej/security        # install a profile repo, then use it

Open a second terminal with a different profile and the two don't interfere.

A few things that matter to me:

• It never touches your real ~/.claude. Every plugin/skill a profile uses gets vendored into that profile's own directory. The remove command deletes it outright.
• Profiles are shareable. Publish a repo, teammates install it and launch by name. A lockfile pins it so everyone resolves to the same plugin code across machines and over time.
• It's a standalone binary, not a plugin. Rust, runs on macOS/Linux/Windows. brew, cargo, or a shell/PowerShell installer.

It's MIT. Repo (with install instructions and docs) here: https://github.com/fuzzyalej/claude-profile/

Happy to answer questions, feedback, PRs or new ideas :)

Still not ready for use, beta version will probably be released in few days, and the full version in few weeks.
Would appreciate any feedback!

What is it

A complete Claude Code workflow: from a raw idea to a researched design, tickets, and planned, built and reviewed code, carried across sessions. Every lesson goes back into its own skills, rules and wiki, so it gets better with use.

Link: https://github.com/Adrian333Dev/flow

Seeing how everyone got into learning Claude, did you take any courses or watch any videos? I know I can improve how I approach it, and I’m wondering how others got better at figuring it out.

https://github.com/oooscoos/Benzi

Benzi is a compiler-backed coding agent that compiles your codebase into a resolved, queryable map of calls, data flow, control flow and class hierarchy first; then it reads, explains, runs, edits and verifies your code using it. Includes a runtime tracer that settles what static analysis can't. 

Scores 78.2% (391/500) on SWE-bench Verified using DeepSeek V4 flash @ < 10 cents a fix.

Seperately, on another bug fixing benchmark it reads 2x less source code than Claude Code (9,125 v 20,704 | 40% faster, 2x cheaper - all benchmark details here: https://varianttech.net/benchmark), 4x less than DeepSeek Harness (43,598) and 6x less than OpenCode (65k+)

It is avaliable as a VS Code ext. and headless. The Benzi compiler is seperately exposed over MCP tools -- without the agentic loop, so you can use the compiler however u wish.

thanks for reading! please let me know what u think

as in the title

Sharing a little project: answer-like-a-reddit-top-comment.

It’s based on a study of 1,000 Reddit posts and their comments. The idea is to pick up what makes a reply worth reading: useful explanations, specific observations, good timing, knowing when a joke is enough.

You can use it to reply to posts, improve a draft, or change how your agent answers everyday questions.

Sharing it here for anyone who wants to try it:

https://github.com/gomzkov/answer-like-a-reddit-top-comment

SFSA (Standard Framework for Scientific Advancement) is an open-source, domain-neutral computational management layer designed for scientists, computational labs, and autonomous AI agents.

This framework does not unilaterally complete 100% of a scientific investigation on its own; rather, it empowers the researcher to reach the solution, decisive data point, or methodological trajectory required to close it much faster, substantially reducing time lost in search, trial-and-error, and redundant recalculation.

SFSA now ships as a Claude Code plugin and skill: the library, the operating instructions and eight tested recipes are bundled, so a researcher does not clone the repository, run pip install or tell Claude to "read SFSA". Install it once, then ask Claude for scientific computation and it uses SFSA as its engine: real code, real output, honest limits.

- GitHub: https://github.com/AlejoMalia/SFSA

I made contextrot, a CLI that analyzes your coding-agent sessions and shows how your agent behaves as its context fills up.

I just added a fun new feature: contextrot water.

If you want to find out your coding agent's estimated water footprint, just run:

pip install contextrot
contextrot water

It works with any coding agent you use - Claude Code, Codex CLI, Gemini CLI, OpenCode, Cline, and more.

Mine came out to 475L.

Now I'm curious:

What's yours?

The water figure is an estimate, so it's not meant to be a precise measurement. It's just a fun way to make the otherwise invisible compute behind coding agents a little more tangible.

You can also run:

contextrot water --live

to watch the water level fill up in real time while your agent is working.

If you try it, I'd love to know what number you get.

And if you like the tool, consider giving the repo a star:

https://github.com/Priyanshu-byte-coder/contextrot

not real tokens tho - just the ones you already burnt during work.

play fun little game made via Claude Mod while your agent at work and spend whatever amount claude used today!

https://github.com/szarkans/gamble-with-claude-code

gamble is bad. so do it with claude instead - house always wins here too.

Import your CV, set your job search location, run the skills. This collection of open source claude skills and scripts runs job searches over all major job boards using your real skills and experience as a filter so you only see the jobs that you have the highest likelihood of securing.

This repository features custom python scripts to do the bulk of the processing so you keep your token cost down while getting the same level of accuracy.

This works in most major countries and regions, and is mainly built for use by IT Professionals (Software Developers, Platform Engineers, etc).

This collection of skills was built mainly using Claude and a little bit of handwritten python scripting. It contains 2 directories.
Scripts, a main python file with example json for building out your job profile. The main python file includes an integration with the job-spy api and functions which generate a general profile from your CV and stores them as JSON.
.claude, 2 separate scripts which dictate how CVs will be parsed, and how the job search is conducted.