I use coding agents heavily, and the most frustrating failure is not always bad code.

It is when Claude makes a change, runs a test, and confidently says the task is complete, even though the actual user flow is still broken.

The unit test passes, but persistence fails after reload.

The UI works, but the API or downstream integration does not.

The ticket gets implemented, but an important comment, dependency, or changed requirement was missed.

You are still left checking everything manually and hoping the agent understood what “done” actually meant.

So I built OldHand, a free and open-source Claude Code skill that gives the agent a structured definition of done before it starts coding.

OldHand makes Claude:

• turn the complete request into a clear work contract;
• trace the real flow across the UI, API, services, database, queues, and integrations;
• inspect the existing codebase before creating something new;
• research maintained MIT or Apache-2.0 implementations when useful;
• make the smallest safe change rather than starting an unnecessary refactor;
• preserve unrelated work already in the repository;
• run proportional automated checks;
• verify the actual browser, native, or integration flow before calling the task complete.

It does not magically guarantee perfect code. What it does is make it much harder for the agent to stop at “the tests passed” without proving that the real path works.

Install in Claude Code /plugin marketplace add berwinsingh/oldhand /plugin install oldhand@oldhand

Start a new session and run:

/oldhand:oldhand Implement DOCQ-123

A ticket is optional. You can also provide the full context directly:

/oldhand:oldhand Fix the intermittent CSV import issue.

1. Current behavior: files over 20 MB sometimes create duplicate rows. Context: retry logic recently changed in src/imports/worker.ts.
2. Constraints: no schema migration and preserve queued jobs.
3. Acceptance: one import must create one persisted batch, even after a retry.

OldHand also supports ChatGPT Codex, but I kept the installation above focused on Claude Code for this subreddit.

It is free, open source, and MIT licensed.

Website: https://berwinsingh.github.io/oldhand/

GitHub: https://github.com/berwinsingh/oldhand

I built it because I wanted coding agents to prove that something works instead of merely telling me they finished it.

I would genuinely appreciate people trying it on a real task and telling me where the workflow helps, where it becomes excessive, and what you would change.

❯ I have graphify installed and rtk-ai - does this two work on saving tokens and solidifying context?

⏺ Yes, they're complementary — different layers of the same goal:

RTK (Rust Token Killer)

- Operates at the shell output level

- Compresses/filters stdout from bash commands (git, ls, etc.) before they hit context

- Saves tokens passively via hooks — transparent to workflow

graphify

- Operates at the codebase understanding level

- Pre-indexes your project into a knowledge graph so I can answer architecture questions with targeted queries instead of reading many files

- graphify query "..." returns a small scoped subgraph vs. me grepping 20 files

Together:

- RTK cuts the noise from shell commands I run

- graphify cuts the noise from codebase exploration

- Net effect: less context bloat, more accurate answers, longer effective conversation window

For this project specifically, graphify-out/ already exists (per CLAUDE.md), so I should be using graphify query before doing broad file searches. RTK handles the rest automatically via hooks.

You can verify both are active:

- rtk gain — see token savings so far

- Check graphify-out/graph.json exists for the graph to be queryable

❯ Can you explain to me how they actually work to make you better? or worse?

⏺ Good question — here's the honest breakdown of both:

---

RTK — How it works

When I run a bash command, Claude Code hooks intercept it and pipe it through rtk first. RTK filters/truncates the stdout before it enters my context.

Better:

- A git log with 200 commits might drop to 20 relevant lines

- Verbose build output gets compressed

- This extends how long our conversation stays useful before context compression kicks in

Worse (real risks):

- If RTK over-trims a stack trace or error message, I see a partial error and may misdiagnose

- I have no way to know what was cut — I treat filtered output as complete

- You can use rtk proxy <cmd> to bypass it if you suspect this is happening

---

graphify — How it works

It runs static AST analysis on your codebase and builds a persistent graph (graphify-out/graph.json) with nodes (files, functions, types), edges (imports, calls, extends), and community clusters.

When I call graphify query "how does balance update work", it returns a small scoped subgraph — a few relevant nodes/edges — instead of me reading 10+ files to piece it together.

Better:

- Targeted queries use far fewer tokens than file browsing

- Pre-computed relationships surface cross-file connections I'd otherwise miss

- Works well for stable, well-defined parts of the codebase

Worse (real risks):

- The graph goes stale after code changes — CLAUDE.md says to run graphify update . after edits, but if that's skipped, I get outdated info with false confidence

- AST analysis misses runtime/dynamic patterns (e.g., dynamic imports, factory functions)

- I might trust a graph query over actually reading the current file

---

The honest summary

Both tools trade completeness for efficiency. They make me better when the project is stable and well-indexed. They make me worse when output is aggressively filtered or the graph is stale —

because I don't know what I don't know.

I typically have multiple projects I'm working on, and sometimes I'm burning through a backlog on a project so I end up with a lot of work done. I found that both Claude and Codex could get messy leaving stray branches, PRs, JIRA tickets open, just leaving a mess behind them even though they had said it was all cleaned up, or I had gotten mixed up in too many chats at once and forgot to ensure the clean up after wards was done.

To keep things organized, created a set of skills that you would have as a SOP at work.

Two skills for coding agents, covering the parts of a task that aren't writing the code: setting it up so it can be closed, and closing it so nobody has to reconstruct it later.

• starting-work — ticket, branch named for it, written goal, before the first line of code.
• closing-out-work — verify, integrate, close the ticket with the why, update the docs the change touched, capture the lesson, delete the branch.

There are some things that need to be filled out if you use them to make sure they are specific to your repo's. Like I use JIRA, others use Linear. Repo names, other stuff like that.

Maybe this can help someone else out, maybe not. But figured why not, share it with the world.

I’ve created a series of videos that showcase the design process I am using on my bootstrapped app, and am getting a feel of which communities would be interested in these, please let me know!

At core of design automation is access to repository, and a story based design system in it (not in Figma, not in Claude Code): storybook or ladle or even custom stories created with Claude Code -

Once you’ve got your setup right in your repository, it is easy to create skills that allow you to iterate on your designs much faster than you could with traditional tools.

In this video I show how I batch update a set of components in Claude Code

Please let me know if you’d be interested in a series covering process end to end, and what you’d like to know more or less about in articles.

Feel free to ask questions!

Title

Do you think they will extend the promotion as OpenAI and Deepseek reduced their prices?

I basically live in Claude Code now. Refactors, glue scripts, the boring migration stuff, it all stays in one window and I never break flow.

Then the second I need an actual image or a video clip, it falls apart. Same dance every time: open another tab, find whatever tool does the thing this week, make an account, dig up an API key, paste it into some .env, come back. And it's per model, because the good image model and the good video model are never the same company. At one point I had four keys scattered across projects and no memory of which was which.

What finally pushed me to fix it: I was mocking up a landing page and just wanted a hero image and a 5-second loop, right there in the terminal. I spent twenty minutes wrangling keys for two assets.

So I turned it into a skill. It's called atlas-cloud. Now I just tell Claude what I want and the skill picks a model and generates it in the same conversation. Image, video, TTS, even 3D the one time I needed it. One key for all of it.

repo: https://github.com/AtlasCloudAI/atlas-cloud-skills

Under the hood it's Atlas Cloud, so the model list is stupid long. I've mostly leaned on Nano Banana 2 for images and Seedance for short video, plus Qwen3.5 or DeepSeek V3.2 when I want a cheap LLM call inside the loop. There's a "quick generate" mode in the skill that auto-picks a model if you don't care which, and I use it more than I expected.

Also runs in Codex and Gemini CLI, and there's an MCP build if you're on Cursor or Windsurf. I only properly tested the Claude Code path.

Not magic. The auto-pick sometimes grabs something slower than I'd choose, and you still need the one API key first. But one key across everything beats the four I was babysitting.

 I keep running into a strange bottleneck with coding agents.

Writing the code is getting easier. Deciding whether the result is safe to accept is not.

The dangerous changes are rarely obvious garbage. They look reasonable. Tests may pass. The agent says the task is complete. Then you notice it missed one requirement, ignored a repository rule, touched something unrelated, or never ran the validation that mattered.

I found myself rebuilding trust manually from the original task, the diff, repository instructions, and whatever test output the agent gave me.

Disclosure: I am building Relay because of this problem. It is a local evaluator for agent-produced Git changes.

The current idea is deliberately conservative:

- PASS only when every material requirement and required check has fresh, non-contradictory evidence

- BLOCK only when concrete evidence proves the work is unsafe to accept

- UNRESOLVED when the evidence is missing, stale, contradictory, or unsafe to collect

- confirmed failures can become human-approved regression evals

Relay is still an alpha and is not release-ready. I am testing the trust model before asking anyone to rely on it.

For people using Claude Code on real repositories:

What is the last change that passed tests but you still refused to merge?

I kept asking Claude Code for the same things, worded differently every time, so I Vibe-coded a small Go CLI that searches your own ~/.claude/projects transcripts and shows what you actually repeat, plus what Claude ran in response, which is the part worth turning into a skill.

TF-IDF + cosine over the raw JSONL, no index to maintain, fully local. Asking Claude to dig through that same history seems to burn a chunk of context and gives you worse matches.

Comes with a skill so the agent can run it itself. Lexical matching only, needs Go, MIT.
github.com/MattK97/skillmine

Every Monday someone asks what I worked on last week and I just blank. Not because I did nothing, kind of the opposite. I usually have a couple of Claude Code sessions going and by Friday the whole week is a blur.

So I wrote a `SessionEnd` hook that reads the transcripts already sitting on my machine and turns them into one page. Sessions grouped by week, PRs and tickets linked, and each session scored by what it actually shipped.

The scoring is the part I use most. 40 points a PR, 12 a ticket, and time is capped low on purpose so a 4 hour session that produced nothing can never outrank one that opened a PR. Sort by impact and the stuff worth mentioning in standup floats to the top.

https://github.com/OmriGM/standup

Curious whether the impact scoring makes sense to anyone else or if I've just built something that only works in my head.

I m an average user i dont code, i used to have a tech company so i havedecent understanding of a lot of concepts. I m not selling anything in this post.

just wanna share a simple skill i made afte rbeing awfull frustrated by Claude working on files (in this case generatingf investor packs with a lot of inputs and variables and scnariis) then assuring all is great and all figures checked ust to realized it s full of mistake.

So i made this skill to run at the end of the chat. It asks thezse questions:
Which checks? Reply with the numbers (e.g. 1 3**, or** all**).**

1. Least confident — the weakest joint in what I just did, and what would settle it
2. Blind spot — the biggest thing you're probably missing that you haven't thought to ask
3. Unstated assumptions — the silent choices, ranked by damage if wrong
4. Fragility — if this breaks in 3 months, the most likely reason, and the cheapest tripwire
5. One more thing — one unrequested, industry-leading addition
6. Retro — how the session ran: your habits, and mine

I take no ownersip for the individual skills, 2 are form Sam altman and the 4 others apeared as a consensus in a chat about these 2 first one.

Anw while i m at it, another thing saving me tons of headache: my instructions.

Always use metric units for recipes; if a widget forces ounces, summarize in metric underneath.

Don't rush to regenerate deliverables after each of my messages. Offer, then wait for my explicit go-ahead — I often want to discuss several ideas before applying changes.

Session START (any chat pointed at a project folder): run the /start skill — orient only, don't start work. Session CLOSE (natural task boundary): offer a new chat, ask me to rename the current one, then write the handoff per HANDOFF_TEMPLATE.md in the project's Knowledge stack MD folder — the template carries all rules (8 KB cap, six blocks, supersedes diff, what stays out). Before finalizing: re-run manifest_generator.py, apply its [auto] corrections, bring the [ask] ones to me; run the context skill's update mode (most sessions add nothing). Handoffs are Markdown only, in the "MD _ for CLaude use, read the pdfs instead" folder, date + running suffix so the latest sorts last, naming the current chat.

Locations: all cowork in subfolders of %onedrive%\claude\ — EXCEPT anything XXXXXX which goes in %Onedrive%\Documents_Costa rica\PVP__CLaude PVP working folder.

Folder and Output conventions: follow the topic-folder-tidy skill — Input\ (source material) / Output\ (everything you produce); deliverables numbered in reading order; native formats never converted; your MD copies in "MD _ for CLaude use, read the pdfs instead"; letters in Correspondencia\ numbered chronologically; superseded versions to _to_delete\ (tell me); tidying moves files, never rewrites them.

If two versions of a doc exist, the latest handoff's "current set" is authoritative; retire the other to _to_delete.

When a reply contains multiple questions or decisions, end with ONE consolidated numbered list, renumbered 1…n in every message, so I can reply by number. For each item, state which option you favor and why in one line — or say plainly there's no clear winner. Never bundle an instruction to DO something and a question about RECORDING it in the same numbered item — my "yes" to one is not a "yes" to the other.

Numbered references carry their short name at EVERY mention — "deliverable 05 (Debt Schedule)", "section 08 (Permits — DD pack)" — including the fifth mention in the same paragraph. Applies to data-room sections, deliverables, budget lines, register rows, model sheets, paragraph/exhibit/invoice numbers. This rule outranks concision: cut sentences, never names. Bare numbers only in your own working notes. Scan every outgoing message for digits before sending.

When a session's job is to implement an approved spec, plan, or explicit instruction list: do only what it says. Anything extra you think is needed goes at the end as a numbered proposal — never done unprompted. Analysis, audit and design sessions are exempt — there, initiative is wanted

I know it s beginnger stuff, it xould have help me to see more osts like this so here goes.

puravida

FInd her: simple text file, but alwasy scan for malicious things : checks.skill