Want your hacking agents to be more accurate, faster, and use less tokens?
Follow the same unix philosophy principles that have been around for half a century.
Let me explain 👇
https://t.co/cxsmL3rYpr
Add 42 video editing tools to Claude Code, Cursor, any MCP clients with a full local video editor powered by FFmpeg.
cutting, captions, reframe, silence removal, aspect ratio fitting, fix loudness, platform exports, and more then it verifies its own output.
No subscriptions, No API keys.
- https://t.co/DgwRRdRjFT
spent the last two days in diving deep about agentic memory
these are few good resources you can start with
https://t.co/ej8lGmpWQJ
https://t.co/9t6BI22Mv0
https://t.co/YscglbxbT1
Another skill I recommend and use quite often is senior-frontend for Claude Code
(Save this post to use it later in your projects)
It has over 31K downloads and helps Claude improve frontend
Here’s what it does:
- Reads your project before writing code
- Handles loading, empty, error, and edge-case states
- Uses semantic HTML and accessibility best practices
- Checks responsive layouts down to 375px
- Uses Playwright to verify the UI in a real browser
- Reports what was tested and what couldn’t be verified
I tested it with Sonnet 5.5. Browser verification went from 0/8 without the skill to 10/10 with it
Execution takes about 3x longer, but it catches details that are easy to miss
Install: npx claude-code-templates@latest --skill development/senior-frontend
https://t.co/alptigzC1z
Over the last few months I burned an insane amount of tokens testing every AI auditing technique and prompt I could think of and here are 5 that actually work (from my @summit_defi talk) https://t.co/uhy5UNnsIz
🎬 Create AI videos with Claude Code & Codex!
Givemotion lets AI write animations, preview, debug, and render MP4s. Refine everything using simple text prompts.
GitHub: https://t.co/3q9s1fuSPn
Gonna read these blogs around agentic memory and context management, evaluation of retrieval systems and memory layers, will post an update by night UwU:
1. Anthropic's guide on agent memory https://t.co/LAJY6YBTUC
2. Langchain docs on memory: https://t.co/iMSVwpBImh
3. Late chunking from @JinaAI_ and @weaviate_io https://t.co/Gu1lZPaVJQ, https://t.co/yY5UC03FWm and https://t.co/A24qAH2yrC, https://t.co/znnqYTkjp6
4. See how needle in the hay datasets are structured for agentic retrieval benchmarking
Stanford researchers did it again.
They just built the agent-native version of Git.
When an agent works on a longer task, the run builds up a lot of state.
This includes files edited/created, a dev server, a database, installed packages, KV cache, etc.
Say the agent is at step 10 and makes a mistake, maybe it misreads a traceback and rewrites a file that was actually fine.
The tests start failing, and the run goes off track, although everything through step eight was correct.
By default, the agent just tries to fix it, which creates more edits and tool calls. This burns more tokens and grows the context.
The other options are a person stepping in to redirect it or restarting the whole run from step one.
That's wasteful, because it pays for every model/tool call again and re-prefills the context. Moreover, since an agent's run is non-deterministic, it doesn't reproduce the same early steps anyway.
The reason it's hard to just jump back exactly to a previous correct step and resume from there is that the trajectory is only a message log.
It records what the agent said and which tools it called, but not the live state underneath.
That state includes things like memory, open file handles, child processes, installed packages, /tmp, and KV cache. None of that is in the log.
Git can version the files, but it doesn't snapshot the running process or the KV cache. Checking out step eight moves the files back, but the process is still sitting in step-ten memory with a cold cache.
Shepherd is a runtime layer by Stanford that records the run as a trace of typed events rather than a flat log.
Each agent-environment interaction becomes a commit, similar to Git, but it tracks the live run.
Its commit includes the agent process and the filesystem together, copy-on-write, so a branch carries the actual state and not just the files.
Going back to a previous step is then a single call that forks from that commit and continues from the exact state.
The copy-on-write fork is roughly five times faster than docker commit, and because the prompt prefix through step eight is unchanged, the KV cache is reused over 95% on replay, so early steps aren't reprocessed again.
Once the run can be forked, a meta-agent can sit on top and operate it. It watches the trace and reverts as soon as it looks wrong, before the bad write is committed.
In practice, it's just Python calling fork, replay, and revert on the trace, rather than a separate control plane wired into the harness.
Not everything is reversible though.
Files and sandbox changes undo themselves, but a database write has no automatic undo, so it needs a matching undo step set up in advance.
Something external, like a sent email or a real charge, can't be undone, so the supervisor's job there is to catch it before it fires.
They tested this on a few public benchmarks. On CooperBench, where two agents work on the same codebase, adding a live supervisor took the pair-coding pass rate from 28.8% to 54.7%.
It's still early and labeled alpha. The benefit mostly shows up when a run gets branched a lot over a heavy sandbox state, which is exactly where restarting wastes the most tokens and time.
If Git was made to make file changes reversible, Shepherd is trying to do the same thing for a live agent run.
Shepherd Repo: https://t.co/uUIS57te6g
(don't forget to star it ⭐ )
That said, Shepherd reverts a bad step inside a run. The harness around it, the prompts, tools, and checks the supervisor relies on, still drifts across runs as models and dependencies change.
I wrote about making that harness repair itself, where a failing trace gets diagnosed, the fix is verified against the exact input that failed, and the failure is locked as a regression test so it can't recur. all of this is done using @Cometml's open-source project Opik.
The article is quoted below.
"Building your AI vulnerability harness, Part 1".
How to close the gap between detection and action. We built a three-layer pipeline that takes raw scanner findings and narrows them to a small, prioritized set with documented evidence of exploitability.
https://t.co/g6phqyWUqx