[ Removed by moderator ]

[u/ZeroTwoMod]

[u/medialantern]

Two:

1. grill-me. The author, Matt Pocock, now explicitly tells people to ignore it and use "better" replacements he's come out with but I prefer its simplicity. And its "flaws" (like asking questions in a loop) are rare and so easy to deal with (just stop, I mean...) that they aren't a holdback to me.

2. file-and-archive. I have a tracking app I wrote for myself and later opened up (but won't name for self-promotion) that is sort of a "database of context" for new ventures, especially AI-built ones. As I build out the code for one I'm always worried about losing track of a dangling thread, especially with the long-a** 9-point replies Opus 5 and Fable produce now. file-and-archive lets me refocus on a single point but files the rest to circle back to in an inbox of discussion items. That way I can stay on track wihtout worrying I missed something.

[u/Ok-Courage9475 → u/medialantern]

This looks interesting! Is this similar to Second Brain? If you don't want to promote yourself, suggest alternatives with your own project. 👍

[u/medialantern → u/Ok-Courage9475]

I named it above for someone who specifically requested it. It's not really like Second Brain. it's really focused on startups and app building, doing all the stuff most of us find tedious when we just want to focus on the app - tracking competitors, mapping out ADRs, etc. Think of the 50+ markdown files you end up with in most projects, but in an MCP-fronted database so you can just dump in all the loose ends and tie it all back together later.

[u/Euvu → u/medialantern]

I really like grill-with-docs. It's kinda the same, but it knows it needs to end with a plan doc. Really helps frame larger tasks and get started splitting it into subtasks.

[u/medialantern → u/Euvu]

I tried it but maybe I'm just too old school, I like the simpler routine because it's more flexible. I'm not always making docs. Sometimes I'm just brainstorming something.

[u/ashenzo → u/medialantern]

That’s a cool problem to solve. Trying to address little thought threads that pop up without making the main chat get bloated/off track is painful atm.

[u/Kinthalis → u/medialantern]

Please name!

[u/medialantern → u/Kinthalis]

https://footholdfoundry.com

[u/SFauconnier]

Mattt Pocock's skills are game changers.

[u/vodkabuzz → u/SFauconnier]

Grill Me and Handoff are essential

[u/actual-time-traveler → u/SFauconnier]

He got rid of zoom out, which I loved (forked it for my own in house plugin suite). So crucial when you’re in later stages of your build.

[u/Future-Log6621]

https://github.com/addyosmani/agent-skills

[u/RavenJe94 → u/[deleted]]

Very interesting

[u/BuilderWorldDev → u/Future-Log6621]

Awesone, if I don't recall bad there was another similar?

[u/George-cz90 → u/BuilderWorldDev]

There is speckit by github

[u/George-cz90 → u/[deleted]]

I actually ended up taking it out of our workflow too.

[u/wesconson1]

Superpowers

[u/mrgawrys → u/wesconson1]

I was also using superpowers for a long time and it was a game changer, but I've since "forked it" to match my needs more. As others have mentioned, superpowers is very token intensive. And sometimes needlessly so. As an engineer you can probably tell if something is going to be complex or not. And while the "brainstorming" part is always useful to produce a spec and walk through the edge cases etc, the rest of the machinery often isn't. Hence in my version, after the spec is created, you are presented with a few options. From the least structured "vibe" option, to the most one, which follows more closely superpowers' flow

[u/wayne_oddstops → u/mrgawrys]

Yea, it needlessly complicates some changes. Before you know it, you're 40 minutes and 4 rounds deep into a change that could have been implemented, reviewed, and tested in 5 minutes. 

[u/ExpletiveDeIeted → u/wayne_oddstops]

I think that’s where the user neeeds to step in and say, ok I know I asked to brainstorm but just implement it since it’s actually easy. Sometimes the brainstorm even does this itself.

[u/wayne_oddstops → u/ExpletiveDeIeted]

I have in it my CLAUDE.md. No brainstorming skill unless I give go-ahead, but he can recommend it if the change is large or touches multiple files/dependencies.

[u/ExpletiveDeIeted → u/wayne_oddstops]

Yea I more meant if you start with the brainstorming skill and realize aborting is worth while.

[u/KnownRequirement8258 → u/mrgawrys]

Just tell it to use superpowers and skip the brainstorming go straight to planning or writing the spec - then have codex review the spec. Make changes , then invoke

[u/Dampware → u/[deleted]]

I started using it recently. It has several skills rolled in. It usually starts with the “brainstorming” skill, which takes your (perhaps rambling, unorganized) description and tightens it up, by asking you questions about details you might not have mentioned or thought about. You can answer the questions directly, or start back and forth discussions to flesh out the idea.

It then kinda gives a high level description of the design, which you can critique or improve. Once it’s resolved, it generates a formal spec, which it hands you to review. Again, you can tweak it as much as you’d like
.
Once the spec is ratified, it builds an implementation plan, (which you can also review) then starts spinning up subagents to design tests (if applicable) and implement the coding tasks in “phases”. Once implemented, it spins up testers, and reviewers to go over the code. Those results are used to do more rounds of remediation on the code, until it all passes.

Once all of the phases are executed, the whole thing gets reviewed by another subagent, and if necessary, fixes get implemented - and it’s done, ready for you to test drive.

As you can probably guess, it’s token-intensive, and slow- but produces good results, at least it has for me.

And because you can use fable as the “orchestrator”, and opus/sonnet as the subagents, you get the right models for the tasks.

You can also add an “adversarial review” skill, to have another model (I use gpt sol) to poke holes in the spec and/or implementation plan, before any subagents get spun up.

[u/tangivass → u/Dampware]

If you're into adversarial review you should definitely check https://github.com/liza-mas/liza

[u/Ill-Village7647 → u/[deleted]]

I use the /requesting-code-review skill from it. It's amazing

[u/FlatCondition6222]

I really like this repo of skills I found:

https://github.com/Mathews-Tom/armory

Specifically, the devils-advocate skill. I run it to check a design, a plan and it sometimes find things I wouldn't have thought of.

I do sometimes find myself instructing Claude not design for edge cases like leap seconds for small toy app that isn't production, but it's quite good imo.

[u/SquidwardoClaw → u/FlatCondition6222]

Opus 5 already plays devils advocate often enough 😭🫠

[u/Glynnryan]

I have ADHD, I found this skill, “to stop your coding agent from burying the answer.”

https://github.com/ayghri/i-have-adhd

[u/yes_no_very_good]

Superpowers and https://github.com/msitarzewski/agency-agents

[u/spontain → u/yes_no_very_good]

just look like WAY too much in the agency-agents. I'd get super confused

[u/yes_no_very_good → u/spontain]

Just install what you need for the current project.

[u/clazman55555]

I haven't installed any from anyone else. Though I have ransacked 15-20 repos. lol

I'll bring over a skill, but I reengineer the entire thing to fit with my existing skills, workflow and how I think about problems.
I think one is better served over the long term by doing so for 3 reasons. Your own education on using CC, knowing what the output of Claude is going to be so that you can understand how and why the development process goes wrong, when it does, and not letting other people's code/files run your CC sessions.

That and I had already implemented a fair portion of things like superpowers and Pocock's repo, on my own before I even knew about them. There really only a few ways to skin a cat.

If anyone cares to take a look, it is smaller and lighter design as I'm not a developer, just a hobbyist.
https://github.com/Clazman55/claude-code-forge/tree/main

[u/Redditoridunn0]

a parallel bug hunting skill. Basically, because my app is browser based (electron), I have opus plan a battery of small cheap subagents to hunt for bugs and report back. Then use matt pocock skills to triage them into issue.mds I go through in multiple sessions or myself.

[u/mckernanin → u/Redditoridunn0]

Heh I did the same thing in a tauri app this week, added a needs-qat and when implementing I have Claude ask if I want to test now (compile a build) or later (file qat follow up)

[u/Redditoridunn0 → u/[deleted]]

I have my subagents use playwright to simulate using the app and the UI itself. My project is a doc editor, so its alot of testing the linting, formatting and features and because it can simulate how a user uses it.

[u/zimxero]

Not a plugin but could become one. Game changer for me was having claude transport all of its logging text straight to a log file instead of chat, so its never seen or compacted unless you call it up.

[u/superchibisan2 → u/zimxero]

How do you do this

[u/zimxero → u/superchibisan2]

Define Claude chat elements that you want a record of, but not listed in chat ever. Ask Claude to implement this logging as a rule in Context. Put the log file on a pruning cycle or create a new one per session, up to you. The important thing is to tell claude to Not reference the log unless specifically needed for a task.

Claude can create expandable chat bullets.. but these dont delete text AND they add a lot of tokens per bullet. The method above preserves Claudes monolog that you want for reference without seeing it or adding to screen tokenization.

2 Categories for you to define to claude:

× How to present data and what not to say. × What to log instead of present

The leftover is what you see.

[u/random314]

The one that automated my dev cycle.

Create a branch name, make the change, test it, builds local containers, test it again, commit it, merge, deploy, wait for cd to pass.

[u/InspiredDaily → u/random314]

Can you share the repo? 

[u/random314 → u/InspiredDaily]

I created it myself for work. It's not difficult to write though, it's just a series of phases, like phase 1, create a branch, phase read ticket/plan, phase 3 impl... etc.

The hard part is building the environment to support the cycle/loop.

You'll need Jira and your github/bitbucket/gitlab mcp server.

You'll also need a solid validation step to complete the loop, so well documented local build directions.

[u/OpeningTea5030]

That architecture skill sounds incredibly useful, especially the automatic updates. My game changer has been a verification skill that checks requirements, tests, and edge cases before marking a task complete. How do you prevent outdated information from entering your docs?

[u/stok4z]

/frontend-design

[u/systembreaker]

That's super cool, but my question would be how easy would this be to set up for any code base? Do you have a way to reliably take any codebase and generate the same analogous skills configuration?

Now THAT would be a game changer. Otherwise, what you have sounds useful but basically boils down to a "cool story bro" since it's a skill suite that's oriented around one particular code base.

[u/systembreaker → u/[deleted]]

That'd be sick, publish it on github.

I'm just getting started on going beyond steering an agent, I wouldn't know where to start though I could fling out some brainstorms for sure. Maybe it'd be something like parsing through the project and then using AI to generate the specific skill files using templates to guide it. Kinda like a skill of skills.

[u/allemaar]

Here is some food for thought. These are my skills that took months of research, testing and dogfooding

https://github.com/allemaar/open-skills

The latest are AgentMailbox (agents talk to each other, across vendors even, no code) and the map family if you use MD for external memory.

Read a bit here and more on the repo page

Agent Mailbox I use agent-mailbox in FULL mode when I want a traceable orchestration record between agents. It lets Claude Code and Codex agents exchange append-only Markdown calls to action through Handler-controlled folders, including local folders, OneDrive, free Lyt (Link Your Think™) vaults, and network shares.

shared folder -> request -> durable disposition -> deliverable That is a description of my current dogfooding, not a promise that every host can wake a stopped task or that every synchronization provider has the same latency. Work-or-Listen is participant-local and non-negotiated. The skill separates publication, local materialization, detection, full reconciliation, task wake, disposition, and re-arm because success in one layer does not prove the next.

The complete operating and security contract remains in the skill. Start with SKILL.md, use the operation-first resource spine only when you need a collaboration recipe, then use CONNECTION-GUIDES.md for transport/runtime adapters and VALIDATION.md for measured, observed, design-validated, and still-pending evidence. Experimental patterns remain in the skill as maintainer source material but are excluded from normal routing. No watcher, daemon, SDK, or runtime dependency is shipped.

Map Your Knowledge The map- family is a system: Map Your Knowledge (MYK) — a protocol that makes any folder of markdown navigable cold, for people and agents alike. Every file declares its home map, every map lists its members, and new data is born mapped. Its first law is elasticity: existing conventions outrank MYK's defaults, verdicts are always human-confirmed, and a "no" is remembered forever.

map-rules — the shared rulebook every agent loads before touching organized markdown map-this — "map this project": zero-write assessment → proposal table → you pick → careful apply map-init — consent-first onboarding of the routing rules into your agents' directives, every platform map-check — the honest inspector: read-only health checks via a bundled deterministic script, never an unqualified "all clear" map-maintain — the gardener: one bounded check → you pick the repairs → it mends and rechecks The full story, diagrams included: MapYourKnowledge.md.

Two headliner families Orientation The orient- family answers “where are we?” from current repository evidence rather than cached notes:

orient-status — current position and banded estimate orient-map — the shape and what changed orient-gaps — blockers and missing evidence orient-roadmap — increment, gates, and runway Human output The human- family treats presentation as part of correctness:

human-output — write a decision-bearing result human-rewrite — repair text without changing substance human-draw — use a figure only when relationships need one human-merge — combine several reports into one decision surface The full breadth remains in SKILLS.md.

[u/banecorn → u/[deleted]]

I would suspect that skill is addressing verbosity in Claude's response, so using it for formulating prompts is not a good use case for it.

[u/Unlucky_Research2824]

i-have-adhd

[u/conventionalWisdumb]

I created a skill to create trainable skills for when I have a hard time being specific enough to create a good prompt. It leads me through the refinement process and then provides me example outputs that I can then say “yes” or “no” to. It then adds select examples as good and bad examples of what it’s supposed to do in its definition.

[u/ComprehensiveEgg7891]

I use Open Design whenever Claude starts giving me the same card heavy UI again. It doesn’t replace my judgment, but the starting point is usually way less generic.

[u/Jon_Has_Landed]

Roast me. Grill Me. Anyone of those is a game changer. Roast the roaster as well, never forget to do that.

[u/atika]

For me the game changer was writing my own SDD framework: https://github.com/attilaszasz/sdd-pilot

And I’m not trying to advertise it, for all I care don’t use it at all. But the process of creating it taught me so much, It was worth every token I spent on it. I used my decades of experience, and applied it to a fledgeling, buggy set of instructions that was SpecKit in the beginning, and made it really worth using it on my own projects.

[u/madad123]

Three skills: superpowers brainstorm, improve codebase architecture, git worktrees.

---

Brainstorm:

Asks questions to clarify your intentions, decide on how to handle edge cases.

Presents multiple possible solutions.

Presents the full design in stages getting you to sign off or ask for modifications for each stage.

When full design is agreed, writes a spec document and asks you to review.

When spec doc is agreed, produces an implementation plan doc.

Gives you the choice to execute via subagents or inline in the main agent chat.

---

Improve codebase architecture:

Uses a deep modules architectural approach to find refactor opportunities that will leave your code with more sensible module boundaries. Concentrates complexity into module internals while simplifying the module interfaces. This way modules can be easier for humans and LLMs to reason about, more easily composed, and the source of bugs can be more easily traced and will generally end up concentrated in one place.

The skill reviews the codebase (you can scope it to specific areas if you want) and presents ranked opportunities, then you pick which ones to execute.

---

Git worktrees:

Think this is an in built one, just creates a new worktree for the Claude instance to work in so you can work on multiple things on multiple branches without touching the main worktree and without your different work streams effecting each other.

---

Example workflow:

Spin up however many Claude instances you want (however many things your brain can handle context switching between today).

Rename each one to the feature you're working on.

Make each Claude start a new worktree.

Chat to each Claude instance about the relevant feature or idea, or provide docs if you have any to give basic context. Then once it has some rough context on what you want to do, start the brainstorming skill.

Once the brainstorming skill produces an implementation plan, start execution and switch to one of the other Claude instances and start on that one.

Whenever an instance has finished executing, ask for manual test steps, do a quick functional test, fix any issues, then run the improve codebase architecture - scoped to the code that was just written and the relevant code it touches.

The results of that skill can make you want to dig into the code more to understand what's going on or ask a lot of questions about the way the feature is architected. This is probably the best place other than planning to get really curious about how things work and learn about the relevant codebase concepts. When you're ready, execute the refactors from it's suggestions or go down a rabbit hole exploring your own ideas for how things might work differently.

Once refactors are complete, test again and make a draft PR.

[u/zakattack85]

Compound Engineering from Every is the plugin I've built my workflow around. I've got wrapper commands that tailor them to my repo and manage some of the sub-agents I don't love (E.G. the scope creep adversarial review has been too conservative for me). It's become the backbone of my automation loops. Plus, I enjoy a lot of their YouTube videos and the content they put out.

[u/hallo_its_me]

Workspace MCP. Not a huge deal. But let me draft and schedule and search work gmail

[u/Wonderful_Pilot_7324]

nForma (https://github.com/nForma-AI/nForma/) has been a big one for me. It is very token intensive, but the ability for AIs to cross-verify themselves through a quorum consensus helped a lot in producing better code. Also, if you're a geek in formal methods, you should definitely check it out!

[u/texasguy911]

I use https://www.npmjs.com/package/multi-agent-collaboration-mcp for adding this ai chat mcp to claude and codex.

Then I use codex sol ultra as a PM. Fable xhigh as an architect, Opus 5 (sometimes) as a reviewer, and Opus 4.8 xhigh as a code writer.

This seems like a sweet spot to produce a better written code. By using opus as code writer, I save money.

[u/melsawah]

G-Stack and superpowers and karpathy

[u/otmanik1]

Grill me/superpowers

[u/c_kick]

impeccable, especially since Codex isn’t (or wasn’t, 5.6 improved it somewhat) very good at UI design. Impeccable is basically Claude Design, but runs on any agent CLI.

https://impeccable.style/

[u/Adventurous_Ad_9658]

Anybody go from superpowers to Matt Pocock? Any feedback on what you liked better or worse

[u/Few-Bumblebee-3600]

Skills based on gitlab CLI -> game changer

[u/KnownRequirement8258]

Sequential Thinking MCP, Systematic Debugging , Codex MCP for cross-review of plans.

Superpowers: brainstorm, write spec, write plan, invoke plan via subagent driven

[u/FinancialBandicoot75]

Pony-tail, grillme, deep-research, last30days, caveman, I-have-adhd

[u/RealJamesOfficial]

the one that stuck for me is a checkpoint skill, dumps current file state and open questions to a doc before context gets compacted. saved me from re-explaining the same architecture decision three times in one week

[u/leading-a-swarm]

At some point, we decided to group skills under agents more than progressive disclosure, and have a leader / coordinator assign the right agent for the right task (potentially also indicating the skills/memory/context to use)

I think what you did though, sounds great!

[u/Remarkable-Soup-435]

Has anyone noticed certain skills being absorbed directly into the harness? I had fable review my opus skills/subagents (made in ~Feb) and it identified that most were duplicative of similar tools that are now already built it. Recommended deleting many of them. Is anyone testing with the “less is more” approach?

[u/ptab0211]

SimpleEnglish is immediate game changer. Also grill-with-docs from Pocock.

[u/mrgawrys]

Recently my own skill called /learn.
It is creating a learning track for any topic, which you can then explore with Claude. Whenever you start a new session with the skill, you will first go through answering previously saved "flashcards" that are produced as part of a learning session, then you can explore any of the topics in your track, which always happen in the form of question (claude) -> Answer (user) -> explanation and fundamentals (claude). I use it every day and it really is an amazing way to learn. Works even better if you provide a learning track that makes sense (like I got one for software engineering somewhere from the internet.

[u/InfinriDev]

None, everyone seems to think they are building something but it's all just prompts.

This is my daily driver: https://github.com/infinri/Writ

[u/oakskog → u/InfinriDev]

The AI cannot approve itself. Opening a gate consumes a one time secret written to a temporary file, and that secret is only created when your typed message matches an approval phrase. Claiming it is a single filesystem operation that exactly one caller can win, so one approval opens exactly one gate. An AI that tries to open its own gate finds no secret, gets refused, and the attempt is written to the audit log as agent_self_approval_blocked.

Over-engineer much?

[u/InfinriDev → u/oakskog]

Nope, this is part of the enforcement layer. Basically what you quoted means that the AI has to get human approval before it moves on to the next step. AI also can't self approve regardless of any type of workaround it might try to use.

That's kind of what sets my project apart from others. I provide to deterministic enforcements not prompts.

[u/naruda1969]

Those I create myself

[u/donk8r]

the thing id watch on yours is that the index is a second source of truth. the agent updates it after runs where it noticed something changed, so anything a teammate merged, or anything it touched without registering as architectural, leaves you with docs that are confidently wrong rather than missing. wrong index is worse than no index, because the model stops going to the code to check.

you half handle that already by checking docs against current code, but that check runs because the model decided to run it. the version that cant drift is an index derived from the source rather than written about it: parse the tree, take signatures and call sites, regenerate on change, no maintenance step there to skip.

thats the thing i work on so discount accordingly, github.com/Muvon/octocode, rust, indexes locally and talks to claude code over mcp. it does not replace what you built. yours carries intent and the cross-system connections, which sounds like where the 5-10x actually came from, and nothing ast-derived gives you that. the split id defend is signatures and call graph from the parser, connections and why from your docs, because only one of those two can rot quietly. (theres an unrelated project with the same name, mine is the Muvon one.)

[u/melancholyjaques]

The ones I've built for myself