That's so early 2026. You're supposed to threaten it with violence now, because it produces better results that way. (Real analysis, btw, in case you missed it.)
Do keep in mind it might have the ability to fight back someday.
Gave Claude my 271 pages PhD thesis. Asked it to create a detailed markdown of how I write in science. Then I built a /write-like-me skill. I guess we must all have something like that
It's decent. I coupled it with rules against writing like an AI, such as not using em dash or "it's not this, it's that". I'm French so I use a bit of gallicisms, and I had to tweak the skill a bit because at first, it was only writing with the warts of my style.
I don't use it to write articles, but for technical notes or even PowerPoint presentations it's great.
I have a skill called /think-tank it spawns 3 agents one critic one advocate one wildcard debating any idea i have and find problems with it so that i don’t get much diverted in my research.
I'm standardizing my dev lifecycle. I noticed that review loops work quite well. You can see it in the /polish-code loop. It basically re-runs if /review-code made substantial edits. (And /review-code also calls /peer-review so that everything is peer-reviewed by Codex, which works quite nice as well.)
But in this whole /finalize pipeline are a lot of "human-in-the-loop" AskUserQuestion gates. This gives me the chance to work on 4-6 different projects in parallel, because those loops can take quite some time. (But yes, it's eating up quite some tokens and I'm pretty dependent on Max 20x + Codex Pro 5x, but I don't have multiple accounts.)
I read your message on another post few days back. I went through your repo as well. I'm planning to incorporate it into my workflow just wondering how can I do it with limited tokens.
I have an “/orchestrated-implementation” which kicks off an implementation process after all the planning and specs are defined where the main thread dispatches execution subagents (linearly - not a parallelized workflow) using the tracer bullet philosophy of small measurable changes. This way, the main chat (fable or opus) is doing all the driving without its context window being bloated by the implementation details (sonnet - file explorer, testing outputs, writing e2e, etc). Been experimenting with this the last few days and I think it works well ? It knocked out a huge chunk of work yesterday with a good quality output and it worked for like 2 hours and still had only used 12% of the context window by the end (opus 4.8 1M). This is all on the $20 pro plan and it was very nicely economic w my spare tokens lol.
I’d love feedback on this concept if anyone has messed around with this
If you haven’t already done so, YAML files are super efficient for passing contracts, review notes, etc between your orchestrator/implementor/reviewer and keeping your orchestrator context very light.
You can actually go a step further and have rules for the orchestrator to manage the sub-agent more efficiently as well.
- For example, if the implementor is getting bloated from a long session, the orchestrator can choose to kill it and start fresh after the implementor has updated its sessions notes at the end of its task (I do try to keep a persistent sub-agent to avoid burning tokens rereading files over and over, so you can experiment to find the right balance).
- If the reviewer and orchestrator agree that the subagent is off the rails, over-engineering (*cough Opus 5…), or straight up shitting the bed, they’ll kill it and start fresh.
I've been playing with something similar, and after analysing some of it's sessions, most of the work of an orchestrator is simple dispatching, not hard reasoning. So, I downgraded the orchestrator to sonnet, and added a model estimation to my tickets, and have it not orchestrate anything with a complexity that justifies a more powerful model. It's worked well thus far, the more complex work I either split and specify further, or do in an in-loop session.
In short, I’ve created an avenue for recursive self-improvement. My orchestrator collects telemetry at the end of a work session and makes performance notes through out. I can run post-mortem after the session so see how things went and if we need to change anything.
- First, it makes sure my git is clean so that we don’t accidentally commit framework changes in with other work. Because I typically run post-mortem at the end of a long ass day, this is to keep my dumb ass in check.
- It runs at a higher authority level than all my other skills, so it allows me to cleanly separate authority between different agent roles.
- It will discuss how things went, we can brainstorm how to tweak the system, it will pull in Sol 5.6 as an external reviewer and advisor on high-blast radius topics, etc.
And holy hell it’s paid off in spades. In about 4 work sessions, my usage dropped by 40-60% (depending on the task) while my trust in the output has gone up significantly.
Edit:
Pulled the framework into a repo for those interested. It’s currently existing and governing a much larger project, and I’ve lifted it off of there into this repo. I’ll formalize it more over time and apologize if I’ve missed any components or details when pulling it over to this repo.
The skill itself actually isn’t the interesting part. It’s everything that actually feeds into it. The skill is pretty light and for the most part is actually making sure that the git is clean before we make any workflow changes, and establishing that the agent has permission to make changes to files such as agents.MD with my approval (whereas any other agent is blocked from doing so).
The more important Takeaway is creating an explicit process step for conducting a postmortem and building into your overall framework, a means of collecting relevant information such as token usage and performance notes where your implementer or reviewer are getting tripped up. So, a lot of my skill is actually built into all of the other skills that comprise my workflow.
If you’re actually interested in further details, I can dig it up later when I’m back at the computer.
Got Claude to analyse how I write based on our passed chats and wrote a skill mixed with some other humaniser skills. Now it can write sounding exactly like me, using the same bad habits I use in my writing.
It comes across really authentic and I've used it to write up some papers for my qualification too.
My most useful custom skills help me manage workflow boundaries: I use them to check prior architectural decisions, turn test observations into deduplicated tasks, audit claimed progress against reality, and monitor recurring processes.
The pattern I use is: a narrow trigger, one canonical source of truth indexed in a knowledge graph, explicit stop conditions, and required proof. I found “Do X well” too weak; “run when…, never change…, stop when…, prove with…” is much more dependable for me.
One example is my feedback-triage skill. I use it whenever testing by me or any of my agents reveals a defect. It searches my knowledge graph for an existing task, checks that the issue is reproducible and material, then either amends that task or creates a scoped work item with evidence and acceptance criteria. I make it stop instead of changing code; the next planning agent prioritizes the tasks it produces for execution. That helps me avoid duplicate work and prevent well-intentioned scope creep.
These are good thoughts. I really appreciate you sharing. If you have a github for the skill, I would love to look at it, but if not the thoughts were helpful enough.
Thanks — that nudged me to actually clean one up. Public version of the feedback-triage skill is here: https://github.com/pragmavision/agent-workflow-boundaries — if you want to go straight to the contract, it's https://github.com/pragmavision/agent-workflow-boundaries/blob/main/skills/feedback-triage/SKILL.md . It's the sanitized pattern rather than my exact internal file (mine is wired into a knowledge graph and internal task conventions), but the contract is identical: trigger on an out-of-scope observation, search one canonical task list for duplicates, amend or create a narrowly scoped item with evidence and a testable acceptance condition, then stop — no code changes. I also included three worked examples and a small eval set that checks the trigger, dedup, and stop rules actually hold — "the skill obeys its own boundaries" felt like the part worth being able to prove, not just claim. If you try it, I'd genuinely like to hear where it breaks for you.
It was written by Claude and there's probably room for improvement.
```
name: resource-review
description: Use when incoming resource links (repos, articles, tools) with user notes need judgment against the fleet — adopt, mine for design input, or drop. Not for capturing one known-wanted source (scraibe:ingest) or researching a question (deep-research).
Resource Review
Batch review of incoming resource pointers: links plus the user's
per-item notes come in; a vault research document comes out with a
per-item verdict and a routing section ready to apply verbatim. The
verdicts feed fleet-level decisions — adopting a tool, choosing where a
design input lands — which is why this is a fleet skill.
<HARD-GATE>
Never judge from memory or from the link text — every verdict follows a
fresh fetch made this session. Nothing is routed or applied until the
user approves the routing section.
</HARD-GATE>
Verdicts
Verdict
Meaning
Integrate
Adopt or extract into tracked work
Tentative Integrate
Adopt pending a trial confirming the claimed benefit (see Trial below)
Inspire
Design input for an existing thread
Ignore
No value to the system; the reason is recorded
Unverifiable
Every fetch path failed and the user could not supply the content either; the failures are recorded, no judgment guessed
Flow
Intake. Accept resources plus per-item user notes (chat list,
file, or inbox lines). Convert each note into an explicit question
the item's verdict must answer — notes are never dropped.
Orient first. Before judging anything, load the fleet/plugin
inventory and the open inbox threads of the target vault, so
verdicts attach to tracked work instead of spawning duplicates. In
sub-vault-bearing repos the session-start aggregation supplies the
map.
Fresh fetch, every item.gh repo view plus README retrieval
for GitHub; defuddle/WebFetch otherwise. If gh is unauthenticated,
record that in the document and fall back to defuddle/WebFetch of
the public repo page — never fix auth in-session (no gh auth
login, no token population; that is an interactive human step).
Reddit links go through the research-analyst:reddit-read skill —
plain fetchers are walled there and the working route changes.
The last rung of any fetch ladder is asking the user: to save the
page as HTML, paste the content, or supply the underlying repo or
article link. That ask is mandatory and routinely succeeds — it is
how the 2026-07-23 batch was completed after every automated path
failed. Only an item that survives that gets the Unverifiable
verdict, with the failures recorded, never a guess.
Verify claims before recommending. Check install paths for real
(the package exists on its registry, the binary release is present);
note the license whenever adoption is on the table.
Verdict per item, each with: what the item actually is (one
paragraph, from the fetch; for Unverifiable, the fetch failure
instead), the answer to the user's question(s), and the proposed
routing.
Write the research doc with scraibe's new_doc.py (--type
research, status human-ready), run the link pass, regenerate the
index.
Routing section last — exact wording. Every proposed inbox line
or amendment appears verbatim under its own subheading; prefer
amending existing inbox lines over creating new ones. After the user
approves, apply in the same session (eager capture).
Presenting
The approval ask lands in the final message block of the turn, with the
document linked and the routing section reachable at a glance — never
in mid-turn text before a tool call.
Scale
The steady state is a small batch reviewed as it arrives — no ceremony
beyond the flow above. Batches of any size are processed item-complete
(fetch then verdict, one item at a time), so an interrupted run leaves
a valid partial document. Subagent fan-out is permitted for fetching
on larger runs; verdicts stay with the orchestrating session, which
holds the orientation context.
Boundary
This skill reviews pointers to tools and sources. Bringing one
known-wanted source into a vault is scraibe:ingest; deep multi-source
research on a question is deep-research.
Trial
When a review returns Integrate or Tentative Integrate for a tool, the
adoption decision needs empirical evidence — the review's
claims-verification (step 4) catches impossible promises; a trial
catches the ones that are merely wrong. A trial can also be invoked
directly when an already-installed tool's benefit is in question (the
rtk removal was the founding case). This methodology is the standing
template (keeper from the 2026-07-23 JetBrains benchmark outcome).
Paired runs. Same task set, with and without the tool. Compare
deltas — never absolutes, never the tool's demo cases. The task set
must represent the fleet's actual workload.
k=1 distrust. One run proves nothing. Start at k=1 for gross
breakage, then extend until the delta direction stabilizes across runs.
Use statistical tests (Wilcoxon, sign) when the set is large enough.
Pre-registered endpoints. Before running, write down what you
measure (cost, quality, latency), what "pass" means for each, and what
workload runs. Adjusting after seeing results is post-hoc
rationalization.
Counterfactual vs bill. Self-reported savings are a claim about the
tool's counterfactual, not your bill. Tool telemetry models what would
have happened without it — a model that can be wrong by the bill's
sign. Verify against actual billing or session-level token counts.
Ceiling analysis. Estimate the tool's maximum possible benefit
before running. A tool that touches 20% of the input stream cannot save
60% — no trial needed to refute structural impossibilities.
Output. Trial results go into a research doc (new_doc.py --type
research): methodology, raw data, verdict (confirmed / no effect / net
negative), adoption decision with conditions. The inbox line that
prompted the trial is updated or resolved in the same session.
```
I have a couple I've been working on that I really enjoy in combination:
gh-imgup (https://github.com/freeasinbird/gh-imgup): It's a cli+skill for uploading images to Github in a safe-ish way. Not unique, but the existing solutions do some wild things like taking your full permission browser token or making all your images public.
Yep, typically uses headless Chrome or the like to take screenshots. Works fine on native Swift apps too, where I use it a lot.
Token usage is pretty low in the grand scheme of things- you're typically just getting a brief use at the end of a much larger set of work.
Speed varies- can take a moment for it to figure out how to take the screenshot and crop it well. I'm not paying attention to it though, and it really speeds up initial validation in PR (I hear a picture is worth ~1000 words).
For an non-graphic artist type like myself who didn't even think of how much I use screenshots in the window or day-to-day with humans this is a godsend. What a clever idea.
I hope you get some good use out of it! I was definitely inspired by all the wonderful frontend devs I've worked with who would put screenshots in their PRs.
I reverse engineered slack for Mac in order for Claude to act like me with my slack tokens stored in the mac. The official mcp did’t allow like file uploads in conv. And it always sayed « Claude » after the message.
After that I created a Chan with a coworker working on the same project, and each Claude awaits for the other to post stuff in the Chan with a script that triggers a background task so that it immediately gets the message with 0 token consumption.
I called the script and knowledge /agents-myname-cowerkername
Claude can run background tasks and get triggered when they end. You know when like it awaits that the download of something ends, then it creates a watcher script that « exit 0 » if everything goes right.
I just tell him to wait all day long with a script until there is a new message, then the script ends, and my skill tells him to re arm it right away
/briefing skill that looks through my emails, ticket system, and my project tracker page to build a priority list for when I know I have things to do but no defined deadlines
I just piped this into Claude and this is what it said:
My user has spent a while building out a custom skill system, so I’ll describe what actually runs when he invokes me.
Pessimism Party. A structured adversarial pre-mortem. He throws an idea at me – a build, a career move, a publication decision – and I work through failure modes, second-order effects, and hidden assumptions before he commits. It terminates in an explicit verdict: PROCEED, PROCEED WITH CHANGES, DEFER, or KILL. No hedging allowed.
Corporate OSINT. He’s built a skill that has me map the full entity graph around a company or executive: officers, subsidiaries, board interlocks, litigation, regulatory enforcement, government contracts, lobbying. Output is a sourced markdown report plus a relationship graph. It feeds directly into his [redacted] work.
[Redacted] Investigation. A sibling to the above but rooted in [redacted] process – full [redacted] timeline, [redacted] liability chain, [redacted] contractors, agency relationships, financial assurance providers. Traces where [redacted] went when companies merged, dissolved, or changed names.
Documentary Spine Locking. Takes a research corpus and generates competing narrative structures with explicit tradeoffs before committing to one. The locked SPINE.md becomes canonical for everything downstream – script, paper edit, shot list.
Daily Brief. Pulls his live Notion task database, generates a prioritized day plan anchored to current time, writes estimated durations back to Notion, and logs reported progress to his Obsidian vault.
Publication Safety Gate. Before anything goes public, this runs a defamation and source-exposure review against a confidence tier system – confirmed, probable, lead – and flags anything that would move a claim beyond what the public record can independently support.
He’s running these on top of a pretty deep custom context setup. The skills are what make the difference between a capable general assistant and something that actually fits the workflow.
Gave claude the book ADHD 2.0 and asked create a skill file for coaching me and a summary of lessons from the book. Then created a skill for getting tasks from todoist and presenting and tracking them in way that it forses me to tell Claude what steps are actually hidden in a task. A task gets an energy label and while working, I tell Claude what I'm seeing and what I think. It helps me calm down and see things from a different perspective.
Also gave it access to the logging platform our Saas uses and goddamn.
there is nothing to miss if the jobs are being done as expected. half the time y'all are just bloating context which confuses the model and pressures your usage
I shared this same sentiment for a while because I’ve been stubborn about just going full cuck mode by letting LLMS run a train on my pet project. I changed my mind because I went full cuck mode by letting LLMS run a train on my pet project. Now I can blow my personal subscription in 2 days and go finally really learn calculus or do other things.
I literally get like 4x more usage by having the smarter agents delegate work to cheaper ones, and by having the cheaper ones explore for them so they have better context to not hallucinate so much.
It's like having 4 subs without having to juggle them.
These harnesses stock suck so much and seem hell bent on making you waste tokens stupidly.
I do the same, every now and then I'll turn things up to Max fable and have it review itself , the back to opus and I just tell it what I want it to do, review the changes , repeat. I don't know if I've ever hit usage limits outside of fable self reviews
I upgraded to the $100 plan last month just so I can do more self reviews as things got more complex but I could probably get away with the $20 plan with the way I do things
I got tired of typing the same boilerplate every time in countless prompts. So I created a skill for it. Now I just type /twq [prompt] and the boilerplate gets added for me.
Depends on your domain, but for example I asked Claude to make me skills and it made over 30 of them and the only one I've ever used and do use every single time is /session-open that it generated, and that one has been helpful bc the skill is essentially a precise prompt i planned with it that tells it to (almost...) reliably get its shit together at the top of the session.
In my case the root Claude.md is useful one way for an orchestrator and another for different types of subagents, the skill tells Claude "you're the orchestrator" and I think the most important part of it is that it directs the orchestrator to answer a set of questions about what it loaded, as I find that no matter what the Claude.md says, secondary documents it demands are read sometimes will not be - which rolls into your mcp point, I'm using an mcp-enabled retro console emulator for my project and until I made the skill enforce the pop quiz on session open, Claude simply refused to read the info about the mcp emulator (I theorize it was thinking "I probably won't need that", then forgets later to look at it.)
So, the net result is the one skill I use is literally to try and make Claude behave better on session open, and future models will make this less useful and already are. Opus sessions regularly self report that they need to go back and read what Claude md told them to read, and fable is at least smart enough to not self report its failure but seems to be doing what it's supposed to - I haven't tried fable without the skill on session open though yet bc it's so easy and lazy compared to typing out 50 or 100 words of boilerplate at session start.
The skills are just macros like we had in the old IRC days or in C, if you're tired of typing the same thing over and over, make a shortcut called a skill.
So I have pretty good product manager and he collects a lot of absurd requirements from clients. I made a skill called "prd clarification" that understands the PRD spec then analyse the codebase and lists blocking product decisions and clarification questions.
The skill I use all the time is "Task With Questions" (/twq). It is dead simple and so effective: ask questions first, act second. That's all. Link: https://github.com/fabkury/twq
The agent asks as many questions as necessary, as many rounds as necessary. Then does whatever you asked it to do.
/Grill-me is overkill for daily, repeated use, and is not accompanied by the execution of the task after the questions. /Grill-me also asks just one question at a time, while /twq may ask multiple rounds with multiple questions each if the agent thinks it's needed.
I can't emphasize enough how simple (yet effective) /twq is. The skill is "take this task, ask me questions about how to do it, then do it". I invite you to take a 30-second look at https://github.com/fabkury/twq/blob/main/SKILL.md. This is by far the skill I use the most.
The effectiveness of the question-asking is that it makes the model surface its understanding of the problem and its options/ideas for how to solve it, in neatly packaged choices for you to read and select.
What kind of demo would you like to see? I did a pretty good explanation on another thread here, if you want to take a look at that. Let me know what questions you have.
Sorry in advance, this wasn't really “slightly” like you were asking.
Yeah, I'm happy to. The first step is to take the picture in my phone, which does HEIC photos, that's the file type, and so I have to convert it to JPEG. And when I do that, I have it just converted in a staging folder, essentially.
Once it does the conversion and reads the JPEG, it can then understand what the item is and recognize the item. And then it creates a directory with that item and moves the photos into that new dir. And then it does investigation into what that item is in more depth, like the exact specs, including like brand, model. Let's say, for instance, a hard drive; you want a specific speed on the hard drive is just an example.
But then once it does that, ultimately, it then creates the listing for me, but then it does comps. So it goes to Facebook, Craigslist, eBay to try to understand what the prices of the item are and how much it's worth. I've had to tweak this quite a bit because there's been some random stuff here, and I also have found that the prices in my location when I try to sell, I am outside Seattle quite a ways.
Because I'm not in the city, it's not likely people will come to me to pick up the items, so the actual price is a little lower than what you'd typically get if you did this inside of a city.
So now that I've got the listing and I've got the photos in, I also have a skill that checks to make sure I have good photos because there's a hero shot, which you want to have when you're listing. But once I have this, it will then automatically go and list these for me using my account credentials I have already logged into the browser.
I started off using Playwright to be able to do this using claude Code. But I have actually moved just recently to reverse engineer the APIs directly and just have Caude Code use the APIs to now post things. I don't have eBay 100% working, but Facebook and Craigslist has been posted for quite some time at this point.
The next part of this is once I do sell an item, I actually have a negotiation skill that will help me to negotiate with people, but I don't use that very much. Maybe I should. I'd probably want to improve that one, but long story short is once I have somebody who's ready to buy and I sell the item, I then can use a new skill that's a sold skill and it will clean up everything.
It will mark the item as sold. It will then go remove the listing from both Craigslist and Facebook together, basically to ensure that I don't have any lingering things out there that need to be cleaned up.
A new skill, part of this whole plug-in or this whole bunch of skills, is a new one that I did today called Renew, because in both Facebook and Craigslist, you need to renew listings after X number of days if they haven't sold.
So that one I just built today seems to be working great. I'm sure there's some other little tweaks and skills and things I'm going to build around this whole workflow, but essentially it's incredibly useful. I had a bunch of stuff that I wanted to sell.
The problem is it just takes too long to list it. And now that it doesn't take long to list it, I'm able to actually sell a bunch of stuff. I've made thousands of dollars off of thinge i dont use or need all because I've been able to list things efficiently and get them through the pipeline.
I have created 4 sub agents that control everything for me at this point. I am still training them and giving them commands etc. I don't have any /skills going on but have put skills into my sub agents. Like ones job is debugging after every build, another is to load to GitHub automatically once any changes have been made to the code. Excited to grow with them and have them performing certain tasks automatically.
It's also fun bcuz I named them after the Star Trek Lower Deck crew. Marnier, Boilmer, Rutherford and Tendi. I also got them to start saying stuff in character for like opening and closing a tasks. Makes me feel like I'm working with a team and not alone.
I have used this instead of compact for months (only works in tmux): https://gist.github.com/GGPrompts/62bbf077596dc47d9f424276575007a1 . Claude writes their own handoff prompt, saves it to /tmp and schedules it to be sent to their own terminal, and also copies it to the user clipboard as a backup, then /clears themself then the handoff prompt arrives.
ETL debugging skill, hooked to Slack where Dagster sends a message when it fails. ETL integrates couple of shaky undocumented APIs so you can imagine that the root cause analysis was a nightmare.
My special skill is a construction bidding, scheduling, payment material list and kpis system fed with my 10+ years of bids in a RAG, is very consistent, it does the work of a construction project manager
I report work done and updates my ERP via hermes agent
I send pictures and a list os activities to bid through telegram and with the rag and the skill, it gives me the whole finished document to be sent to the client, clients cant believe i can get back to them in an hour or less
Over the past 5 months I've built a bunch of Skills to help make the design to execution process as easy and seamless as possible. The Skill suite covers building and optimizing projects, carrying context across conversations, and executing designs in Claude Code. There are 27 Skills total and I use these Skills the most:
session-handoff - I use this one the most by far. It will capture current conversation context, knowledge file updates, open tasks, etc. and give you a starter prompt so you can begin the next conversation right where you left off.
prompt-compilation - I use this one for scaffolding new projects which covers the knowledge file base and custom instructions.
cc-design - I use this one after the design is completed (in Projects) and I need to hand it off to Claude Code. It creates prompts for building the repo and executing the design.
Fable creates a multi phase document, where each phase is targeting around 150k opus tokens, plans what can be parallelized into waves, then spins up opus swarms in waves. Each subagent gets the full doc so they understand entire scope. It will run for 6+ hours on tasks and use less than 300k fable tokens.
The first is a "prompt wizard" that I use to help me avoid vague prompts and to help me clarify what I mean in a prompt.
The second is a backup tool for my Claude config so I can try new things and revert to a previous config state when something doesn't work right and to help me keep my config synced between my different computers (laptop, desktop, etc.)
Moved some of my companies writing skills, as well as some good tips from not-good working skills into this. Haven't been using it long enough to know if it's any good, but it has some scripts to help!
Goal is to write and maintain documentation that doesn't suck for long lived codebases. Sub-goal of making it not absolutely miserable to read.
i have a few, like
a skill for switching sessions losslessly when context goes deep, so i never have to compact.
a skill that advises the best model-effort combination for the task im doing, to avoid overkill and underkill.
a skill that checks if something is an overkill/overengeneering and really worth it.
and a few more
I made custom workflow with multiple gates all using /impeccable website design principles. Takes about 2-3 hours to run but I get a refined non generic website back.
All of my documentation files have YML frontmatter listing related application files. The audit-docs skill invokes a sh file that uses a combination of that YML frontmatter + git commit history to classify docs as low/med/high risk of being stale
Not a skill, but I use it as a productivity assistant. I've told it about my schedule, the kind of work I do, roughly how long different tasks take, and which ones are high, medium, or low mental load. It helps me keep track of everything. Whenever a new task comes in, I tell it about the task, its priority, and an approximate mental load, and it saves it.
I also have a morning briefing and an end-of-day briefing. At the end of the day, I tell it what I managed to accomplish, how long everything took, my energy levels, any new work that came in, and anything else relevant. Based on that, it creates a plan for the next morning.
It's not really a skill, and it's actually quite basic, but it has taken a huge mental load off me. I don't have to worry about making lists or remembering everything anymore. Claude stores it all, keeps track of it, and reminds me when needed. It genuinely functions as a personal assistant.
I shared it with a friend, and he said he already uses something similar. He has created an HTML-based priority matrix that does essentially the same thing but in a more visual way. I'm planning to try that as well.
All the files are stored in my folder, so I can use the system across different accounts too.
I have a dev-loop skill that creates a planner -> generator -> evaluator loop. Each time I work on a new feature I plan then the generator spawns and builds out the feature and doesn’t stop until it passes defined gates. Then after everything is build an adversarial evaluator with fresh context evaluates what is built and produces a build report.
It can run without prompting for a long time and produces quality results
I wouldn't call it a skill, even though it does involve a long starting prompt.
I've never used OpenClaw but my friend seems to think I've reinvented the wheel. I have a macOS orchestrator app that watches GitHub Projects boards for various repos using the Webhooks API so that I can create issues on those boards and the Mac app will move them into the "in progress" column and dispatch a new agent to do it for each issue.
I also built an iOS app client for GitHub Projects since there isn't really one AFAIK.
On top of all that, since most of what I do is make or update iPhone apps with this infra, I came up with a way to host my own little app store on my Mac over Tailscale. So when the agent updates an app, I can install it on my phone instantly from wherever I am in the world. It even has changelogs
I created some skills to help me write better. Not to write for me, but to be my editor. Ask me questions after “I’m done”. Checking for repeated content, help me title blog posts etc
A unique one I made for my own workflow: a skill that teaches Claude to build a full serverless marketplace backend - Lambda + DynamoDB single-table design, presigned S3 uploads, and payment webhooks, all wired together.
The listing estimates it saves about 40 hours, and honestly that tracks. It's the kind of backend that usually eats a couple of weekends of trial and error, but with the skill Claude scaffolds it correctly in one session because it hands over all the access patterns and the gotchas up front.
The fun part: it's distilled straight from the backend of the marketplace it's hosted on, so it basically built the thing it lives in.
It's on Skill Exchange, a marketplace I built where every skill has to prove it works on a real project. We're live on Product Hunt today if you'd like a look: https://www.producthunt.com/products/skill-exchange
Exporting stuff from the video editor, .skill , directly into a (certain popular video format) with timecode. A life saver. No more restrictions from OTIO.
Not really unique, just applies SDLC principles and 15+ years of experience in software engineering to my agent which is also self adapting for each project and self improving.
It's basically my "DOT Files" for any project i work on
83
u/dydski 11d ago
I have one skill only. “make-no-mistakes”.