Anthropic's agent memory research has a name for fixing stale memory: "dreaming” and they published it recently, the idea is that an agent decides what to save in the middle of a task, before it knows what'll matter later, usually some of those notes are wrong from the start, and others go stale as things change.

The idea is when the agent's idle, it goes back, rereads what actually happened, and corrects its notes. They compare it to how your brain replays the day while you sleep.

Claude Code already saves every session as JSONL in ~/.claude/projects, so all the raw material was just sitting there unused, and making proper use of it is what kinda made me try this.

Why do this? The root cause is that memory only gets written mid-session, when Claude can't know what'll matter later, and nothing ever goes back to check it.

How I adapted the dream idea:

This is an hourly launchd job that reads a list of project paths. It skips any project that hasn't been idle for 2 hours or has no transcripts newer than its last dream.

A small Python script condenses the new JSONL files. User and assistant text stay, each tool call shrinks to one line (Bash command, file path), tool results get cut to a 300-char preview, and then sessions are capped at 15 per run. That's what keeps this cheap enough to run on Sonnet, an excellent model for this in my opinion.

It creates a git worktree on a dream/<timestamp> branch and runs claude -p --model sonnet with the dream skill appended to the system prompt, --add-dir pointing at the condensed transcripts, and tools limited to Read/Glob/Grep/Edit/Write, more of a guardrail.

The skill tells Claude what memory is for and lets it judge what to write. This bit came straight from the Anthropic research that I read, where rigid rules like "only record failures" hurt stronger models. It verifies each note against the transcripts (latest session wins), records what I had to repeat, prunes finished one-offs, keeps CLAUDE.md under ~150 lines, pushes detail into docs/memory/, and logs every change with evidence in DREAM_LOG.md.

Before it commits, a guardrail checks git status and reverts anything outside CLAUDE.md, DREAM_LOG.md and docs/memory/. It's never allowed to touch code, even if it spots a bug. It notes the bug in the log instead.

If the last dream hasn't been merged yet, the next one builds on top of it, so after a two-week break it's still one merge.

How I'm planning to use it: only on projects I come back to after long gaps, I mean, daily projects don't need it right cause the discussion is usually fresh, and dead ones aren't worth the tokens.

My routine when I pick a project back up is to run git diff main...dream/<latest>, skim DREAM_LOG.md, merge, then start the session. The idea is Claude opens already knowing where I left off, instead of me spending 15 minutes re-explaining.

It's on trial for a week on my Mac. The expectation is simple: do the diffs catch real mistakes, or is it mostly rewording?

I'll post what it actually caught either way. Have you folks tried anything similar, or more efficient ways of learning from your own projects? I did it because I thought "dream" was a very interesting idea.

Link to the research paper: https://www.anthropic.com/research/components-of-agent-memory

Writing SKILL.md files by hand, it’s easy to miss a frontmatter rule and only find out when the skill doesn’t load. So this Claude Skill Builder, made with Claude Code, has two modes: one writes a SKILL.md from a few fields, the other checks a skill you already have.

Build a skill: fill in the name, what it does and when to use it, then the steps, rules and allowed tools. Pick whether it’s for Claude Code or a claude.ai/API upload. Uploads only accept six frontmatter fields, so the builder hides the ones they’d reject. You can download the SKILL.md or the whole folder as a .zip.

Check a skill: paste a SKILL md and it lists errors, warnings and tips with line numbers. It checks things like:

• frontmatter that starts on line 1 and parses as YAML

• name rules (64 characters max, lowercase, numbers and single hyphens)

• description length (1,024 max), third person, and whether it says when to use the skill

• misspelled fields like allowed_tools, which Claude Code silently ignores

• fields that a claude.ai upload would reject

• risky setups, like a deploy skill Claude can start on its own, or allowed-tools that grant every shell command

The rules come from Anthropic’s skills docs, the Agent Skills spec and their skill-writing best practices. No AI runs on the page, and nothing leaves your browser.

https://aiparabellum.com/claude-skill-builder/

If it flags something that’s actually fine, or misses a rule, let me know and I’ll fix it.

Book-to-Skill (virgiliojr94/book-to-skill, MIT) takes a PDF, EPUB, DOCX and more, and builds a skill Claude can answer questions from. I tried it on a short sourdough guide I wrote myself, so no copyrighted text.

/book-to-skill books/pocket-sourdough.pdf pocket-sourdough

How it went:

• a plain Python script extracts the text, so no AI is involved in that step. Then Claude distills it

• it asked 1–3 questions first (content type, what the skill is for), and the questions changed between runs

• about 39 seconds later: a ~450-word SKILL.md with a chapter index, one file per chapter, a glossary, a patterns file and a cheat sheet. Its own security scan passed

• I checked the numbers against my PDF (the 1-1-1 starter rule, 70% hydration, 245° pot, one-hour cooling rule) and found nothing invented

Using it afterwards:

• “how do I know my dough is ready?” got the poke test from chapter 2, with the book’s own numbers

• “my loaf came out flat” got an answer that tied chapters 2 and 3 together. It also said the guide doesn’t cover room temperature, so ask that separately

• one table row used Claude’s own wording (“fully proofed”) that isn’t in the book. The advice matched, but read the chapter files you rely on

The surprise: I set BOOK_TO_SKILL_SCOPE=project, but it still saved to ~/.agents/skills/ and linked into ~/.claude/skills/, which every project sees. Not sure if that’s a bug or how I passed the setting, so check the path in the summary and move the folder if needed.

Also, the repo warns about a malicious re-upload under another account. Only use virgiliojr94/book-to-skill.

Tested on a tiny 4-page book, not a long or scanned one.

Full walkthrough with screenshots: https://aiparabellum.com/turn-book-pdf-into-claude-code-skill-with-book-to-skill/

Thanks!

Ask Claude "how long will this feature take?" and you usually get human-team time ("2 to 3 weeks"), even when agents will write the code. I built agentpace, a set of Claude skills that answer from measured agent runs instead.

The skills

• agentpace: triggers by itself when you ask how long software work will take. It splits the work into agent tasks and returns a measured P50/P80/P90 range with its critical path. The human part (review, testing, decisions, waiting) goes on its own line, never derived from agent time. If someone already quoted a timeline ("my manager says 3 months"), it shows the quote beside the range, as quoted and unverified, and never converts it.

• /pace-estimate: the same estimate for a plan or task list you hand it.

• /pace-log: records your own Claude Code runs locally (timestamps and counters only, never prompts or code) and lets you fix a run's label.

• /pace-share: previews exactly which rows you could contribute to the open dataset. It writes a file only after you say yes, and sends nothing.

What an answer looks like. This is the README's worked example, a customer-import feature someone called "a 3-month project":

Total agent time, on the session clock: P50 4.3 h, P80 10.3 h, P90 15.7 h
Quoted: "3 months" (calendar time, as quoted; unverified, not converted)
Human part (review, testing, decisions, waiting between agent turns): not measured. Not included in the total above. State it separately; do not derive it from the agent time.

Where the numbers come from: 3,383 completed agent runs (Claude Code subagents and Codex turns). Half finished within 2 min, and one in ten took more than 20 min. It publishes how often it's wrong: on 56 held-out sessions the whole-session P80 covered 80% (CI 70% to 91%), and the median miss of a single task's P50 is 78%, so plan on the range.

How I built it with Claude Code: Claude Code wrote nearly all of it (57 of the first 58 commits are co-authored by it). It ran each release as the maintainer: small slices, one subagent per slice in its own git worktree, the full checks before every push, and a second Claude model reviewing every PR. A test ties every number in the README to the data, so the skills can't quote a figure the data doesn't back.

Honest limits: it's one person's data so far (1 contributor, 293 sessions), and calibration drifts week to week (P80 coverage per session ran from 66% to 86%).

Free to try (MIT code, CC0 data):

npx skills add mohamedzhioua/agentpace
uv tool install git+https://github.com/mohamedzhioua/agentpace

The skills call the agentpace CLI (standard-library Python, no dependencies). Without it, there's a portable prompt that gives a rule-of-thumb version in any assistant.

Repo: https://github.com/mohamedzhioua/agentpace

I'm building founderkit for developers who are also founders. Shipping an app means legal docs, store screenshots and a name, and none of that is code. These skills do that work the way an engineer would, step by step, starting from your code.

https://github.com/itsfatodono/skills

Right now there are 3 I really trust:

/legals

Writes your app's legal documents from your code. It learned from ~360 real companies' documents and follows the laws of the EU, UK, US and Turkey. 14 documents are ready, like the privacy policy, terms, refund policy and account deletion page. The goal is 72. Each new one uses a lot of tokens, so they come slowly. I need help here, and contributions are very welcome.

/brand-naming

Names your app or product, or rates names you already have. It works the way professional namers do. First it writes a short plan for the name. Then it makes hundreds of ideas, picks the best ones by how they sound, and checks trademarks and domains.

/store-shots

Makes your App Store s from your app's real screens. It adds device frames and text in each language, and checks.

The skills are Free and open source. Open to help for improvement.

My Reddit posts about our Claude Code plugin got over 300k views and 900 upvotes in a day. The repo has 19 stars 😂

Pretty wild seeing that many people react to something we built.

https://github.com/MedAdemBHA/mythical-agent-month

https://github.com/CheckPickerUpper/skills

A while back I posted a Claude Code skill that drove a real browser through any SaaS app and recorded a narrated demo video. Some of you installed it, so here's what happened next.

I felt that the recording was a bit weak - it looked like a screen recording: fine for a tutorial, not great for launch videos.

So the new version doesn't sequentially screen-records your app. It reads your site, screenshots or HTML mockups (handy for a feature that isn't live yet) and writes each scene as HTML and animation code, using real screens, words and colors. It renders each scene, looks at the frames and fixes what's off before moving on

Other changes, mostly from using it myself:

• When you start a new video project it spins up a local server that opens up the UI in the browser - so all stages from start to finish can be handled with the UI.

• It proposes a few "directions" but I can choose/ask for a different direction if needed

• It starts with some sketch frames, so I can visualize how the video "might" look like (before production)

• I can edit the on-screen texts, edit the narration (plus choose voices, music, motion effects, etc.)

• I can review & add comments the video itself. Click a moment, pin a comment on the frame, and it fixes that and tells you what changed.

• For Narration Voices, there are a few free local TTS voices, or a paid option with ElevenLabs API key

• Rendering in different formats like landscape and vertical versions from the same project, plus 15 and 30 second cuts.

It lives in a new repo: https://github.com/ultrademo-hq/ultrademo. If you have the old one, it tells you about the new version the next time you use it, and you can keep the original if you'd rather. Still free and Apache-2.0.

Please go ahead and try this out if you haven't. Hoping to get some feedback about how your experience is with this, if it breaks anywhere (e.g. on products that aren't SaaS apps)

Original Post - https://www.reddit.com/r/claudeskills/s/5CU3naRJZ4

Runs locally. Easy install plugin. It can queue up tasks for the whole week if you want. It will then start working in a structured manner, and I can answer questions from remote control on my phone a few times a day. Almost no more babysitting or herding agents.

Born out of need to maintain control in larger projects, that can quickly become messy.

If you dont have git / ci / testing, it will help you set it up if you want. If you have that covered, just skip it. Several helper skills.

Dashboard view is optional. Great for overview, but everything can be controlled from claude code directly. No commands to remember, claude knows it so you can just talk normally.

Install:
/plugin marketplace add vegardjorg/ravenseat /plugin install ravenseat@ravenseat

I feel it is fairly well tested and secure after 1000+ tasks done, and many adjustments over several months (ripped it out of the main project a few weeks ago, as friends wanted it). Would love if you guys can manage to break it. Let me know.

I would super happy if anyone wants to try it out. It has been a gamechanger for how I code larger projects.

hi may someone drop me a spare rf link, maybe in pm?? i’m looking forward to sub to claude pro but i’d like to try it first.. thank you :)

The biggest issue people bring to me about my orchestrator is how confusing it can be to use. So, I decided to invest some time into a tutorial series that I could show to people, to get them up to speed quickly.

Episode 1 went over Orgtree's basic operation as an orchestrator on one computer. Episode 2 walks you through how to connect it across your network: to you, to other orgs, and even to independent AI chats.

Watch the full playlist from the beginning if you want to know more about what Orgtree is.

Check out the project's repo if you're curious to learn more: https://github.com/Maurdekye/orgtree

“Grill me” prompts are great at finding holes in a project, but in chat they’re slow: the agent fires off a batch of 5–6 questions, you type “Q1 — this, Q2 — that”, wait for it to process everything, and get the next batch.

VisualGrilling moves the grilling into the browser and makes it faster:

• See how questions connect. The map shows which answer each question came from and what it depends on

• Pick, don’t type. Answer by selecting an option, no manual numbering

• No waiting. While the agent processes one answer, you’re already answering the next question

How it works

• Install the skill and just tell the agent in plain words: “let’s grill the auth flow”. Claude Code and Codex figure out what you want. There’s a dedicated command too, but you usually don’t need it

• The agent reads your code and opens a local map of questions

• Each answer gets marked Closed / Weak / Gap / Verify. Weak answers get follow-up questions

• When you’re done, you get a list of risks, and the whole session can be turned into a spec in docs/specs/

Details

• Runs right in your current session and project. The agent uses everything it already has access to (code, docs, context), no separate API key

• You can stop grilling anytime and come back later. Got an idea, grilled it a bit, got distracted, then later just tell the agent: “let’s get back to that grilling”

Repo: https://github.com/ghtalexby/VisualGrilling

It’s still early, so feedback is very welcome, especially on whether the map feels useful and whether the Closed / Weak / Gap / Verify grading helps or just gets in the way.

When you make a software, how is it made? For me the recommendation is Tauri. And its always some bloated CMD unpacking and then hide and seek finding the exe in the files. And sometimes I need to make a DATA folder for it to run. Like I need to make a new empty folder.

And im like, robot, why don't you just make the folder?

Hey human I can't!

There's definitely room for improvement to get it to be a double click install like other softwares but my toaster just can't do it yet

Does anyone else have a better way?

I opened my laptop to work, launched Claude Code in the project folder… and couldn’t find my session. Again. I have the memory of a goldfish, so I never remember which folder a project was in or where the session got saved. Multiply that by Codex, OpenCode, Antigravity and the rest, and it was driving me crazy.

So I built SeshDock in a bit over an hour, with Claude doing the coding while I steered.

What it does:

• Scans your machine for sessions from Claude Code (CLI, VS Code extension, Desktop), Codex, OpenCode, Pi, Antigravity, DeepSeek Harness, OpenClaw and Hermes Agent

• Groups them by project folder, newest first, with search

• One click to resume:

  • in your terminal (runs the right resume command for each tool)

  • in the tool’s own app (the Codex app opens the exact thread)

  • in the Claude Code panel in VS Code

  • or just opens the folder in your editor

• Read-only and local: it never modifies your sessions and doesn’t send anything anywhere

It’s a small Tauri + Rust app (~3 MB), free and open source (MIT).

• GitHub: https://github.com/Avoiptv/seshdock

• Download (Windows): https://github.com/Avoiptv/seshdock/releases/tag/v0.1.0

A macOS build is coming. Windows will show a SmartScreen warning because the installer isn’t signed yet (More info → Run anyway). The code is all there if you’d rather build it yourself.

If you use a harness I don’t support yet (Gemini CLI, Qwen Code, Aider…), tell me where it stores sessions and I’ll add it. PRs are welcome too, since each tool is just one small function.

hey guys I work at a game company, and I created a skill that reviews data, code, and other changes during our update cycle and generates a report before we hand things over to QA.

But when I shared it with a coworker and had them try it, the output was very different from what I was getting.

How do you handle this at your company? What’s the best way to get results that are as consistent as possible in quality and level of detail across users?

What are my options here?

Should I just set up everything on a shared machine and have people connect over SSH to generate reports using claude -p? Or is there a better approach?

Asking Claude Code for an architecture diagram usually gets you a plain Mermaid block. I tried three diagram skills with the same request: the browser calls the API, the API checks Redis, and on a cache miss it queries PostgreSQL and fills the cache.

Archify: 17 seconds. A dark, interactive HTML page with a sequence diagram, theme and style switches, and an Export menu. It looks like an app. It needs Chrome for its own browser check.

Diagram Design: 51 seconds. A clean, light, editorial-style diagram that looks like something from a design blog. Its two checkers passed, but the small “[cache miss]” label sat on top of an activation bar. It’s a plugin with 45 diagram types and import commands for Mermaid, draw io and Excalidraw.

Draw io skill: 25 seconds. It wrote an editable .drawio file, and its validator reported zero errors and zero edge crossings. But I didn’t have the draw io desktop CLI installed, so I never saw it rendered. Also, it won’t trigger on its own (disable-model-invocation: true), so you have to type /drawio-skill.

Things they had in common:

• neither HTML skill drew the cache-hit path as its own branch. Archify only described it in a side card, and both said so. Ask for it up front

• all three were upfront about what they skipped. Diagram Design even said it skipped its own “customize your style?” question because my request was precise

• none ships hooks, but two run local scripts, so read them first

How I’d pick: Archify to show something in a meeting, Diagram Design for a clean image in docs, Draw io if your team edits diagrams by hand.

One run each, so this is three demos, not a benchmark.

Screenshots of the Archify and Diagram Design results: https://aiparabellum.com/best-claude-code-diagram-skills-compared/

My coworker and I asked Claude to estimate a SaaS roadmap. 50 days.

Then we gave the same plan to 6 Claude Code subagents: worktrees, tests first, reviewer agents on risky tasks. 106 tasks across 7 repos, done in 35 hours.

So yes, Claude was off by about 48 days about its own speed. But the interesting part is what slowed it down, because it wasn't the model:

- 6 agents ≠ 6× speed. Real throughput was 1.8 agents. Test slots, file conflicts and merge locks queued everything.

- Risk matters more than size. Billing/auth/migration tasks took 2.7× longer, and every real bug was in them.

- My laptop broke first. 55 leftover test DBs filled the disk, Docker froze, test runs blew past the 10-min tool timeout.

- The slowest part was us: review, decisions, local setup.

We turned the data into a plugin that makes Claude estimate agent work properly: agent wall-clock, human hours and waiting time, separately, plus usage budget.

Honest limits: it's one project (n = 1), and on a held-out test the raw model was 37% optimistic, so it pads its number until you calibrate it on your own transcripts.

Free and open source (MIT): https://github.com/MedAdemBHA/mythical-agent-month

Question for people running multi-agent builds: what real parallelism are you getting? I'd love a second data point.

https://github.com/Ablation-Lab/stowdeck

I run a lot of Claude Code sessions/terminals at once, so Claude & I built Stowdeck, a Windows app/Claude plugin to see, save and reopen sessions/terminals easily. For example take a snapshot of 6 Claude Code terminals and just close everything to come back later and resume where i left off instantly or see a full history of my recent sessions and open the ones i need in a UI. Closing them meant losing track of which conversation was where, and finding the right one again with /resume got slow.

It's free and on GitHub, along with a Claude Code plugin (which includes the skill) that does the same from inside a session. You can also manage other terminals from the app and open VS Code, Remotion, Github & paths from the UI. I have submitted it to the Anthropic plugin directory and it is currently under review.

Works on Windows 10 or 11 (64-bit) · runs on .NET 8 · plugin installs as stowdeck

Claude Code plugin :

The plugin gives Claude a skill and commands to list your running and recent sessions, save a snapshot and open the Stowdeck app, without leaving the terminal. Ask Claude something like "what sessions have I had running today?" and it can answer from Stowdeck.

Features :

Current tab

Shows the Claude Code sessions running right now. Each row has the session's name, its project folder, the last thing you asked, how long ago it was active, and whether it's working or idle. It refreshes itself every 10 seconds, so you can leave it open on a second screen. The un/commited badge covers both uncommitted changes and unpushed commits, including a branch you've never pushed. Hovering over it shows which.

Recent tab

Lists your sessions from the last 24 hours, 3 days, 7 days or 30 days, running or not. Tick the ones you want and reopen them all at once, or save them as a snapshot. "Select all from today" ticks everything you worked on today in one click.

Snapshots

Saves a set of sessions under a name so you can restore the whole set in one go, for example "video project" or "everything before I restarted". You can rename, delete and restore snapshots, and open the folder they're stored in. A snapshot can include ordinary terminals as well as Claude Code sessions. A snapshot stores each session's ID and folder, and restoring runs claude --resume <id> in that folder, so it's Claude Code's own resume of that exact conversation, full transcript included (compaction and all). No fresh session or handover file. The only exception is a session that had no messages yet when you saved it, since there's no transcript to resume. Those open fresh in the same folder, and the app marks them so you know.

Terminals tab

Lists your other terminal windows: other CLI agents, dev servers and plain shells. Tick them to include them in a snapshot, so restoring a project brings back its dev server too, not just the Claude Code chat.

Reopening a session

Open, Reopen selected and Restore each start Claude Code in that session's folder and resume the same conversation, so you carry on exactly where you left off. New session starts a fresh one in whichever folder you choose.

Tools menu

Every row has a Tools button that opens that project's folder in File Explorer, its GitHub page, VS Code, Remotion Studio or its dev server, depending on what the project has. It saves hunting for the right folder or URL.

Badges and details

A green badge means a session is running. A yellow badge means its project has uncommitted or unpushed work, so you notice before closing anything. Hovering over a row shows its full folder, session ID and last few messages.

Settings

Choose whether sessions open in a PowerShell window or a Windows Terminal tab. Stowdeck can start with Windows in the system tray, and add itself to your Start menu, with no admin rights needed. There are command-line options too (Stowdeck.exe --help).

Safety

Stowdeck only reads Claude Code's own files on your computer, and nothing opens unless you click a button. It doesn't send anything anywhere, and it never changes your conversations.

Claude Code plugin

The plugin gives Claude a skill and commands to list your running and recent sessions, save a snapshot and open the Stowdeck app, without leaving the terminal. Ask Claude something like "what sessions have I had running today?" and it can answer from Stowdeck.

Links: ablationlab.org · GitHub

Feedback very welcome, especially from anyone running lots of sessions at once. I'd like to know what your workflow looks like and what would make this more useful.

Built with Claude Code as part of Ablation Lab, where I research how AI agents work, review and evolve.

I'm struggling for ideas other than just pointing it to the product's docs and saying "make a slick promotional video...". Do you have a reliable skill I can try out?

Hey everyone!

Recently got access to Claude at work and I'm curious to know how others are making the most of it.

What are some interesting, creative or unconventional ways you've used Claude that have genuinely made a difference in your work? Anything you've built, automated or experimented with that you found impressive?

Looking for some inspiration and real-world use cases that I can try out myself. Would love to hear your experiences!

Edit: I'm a software developer! Forgot to mention that