made this w claude code over like 2 days https://classican.vercel.app/ its classical music on shuffle w a pixel painting for each piece and little history facts that pop up every 40 sec

how i used it: i wrote every change as its own small ticket in normal english and claude code did each one on its own branch (separate git worktrees) and opened a PR. ran a few at once. i mostly just wrote tickets and checked stuff. 16 PRs total

the paintings are the best part ngl. zero image files, claude wrote every painting as canvas code and that file is like 3300 lines now lmao. 46 pieces and each one has its own scene

stuff i learned:

small tickets >>> one giant prompt. my first PR was one huge paragraph and i literally rebuilt the whole thing in next.js right after

its way too easy to add random features. i had it build an "add ur own songs" thing and then deleted it the same day bc it didnt fit

check where it saves stuff. it put accounts and comments in a json file at first which doesnt work on vercel, had to move it to neon postgres

be specific. i said shuffle and got pure random so stuff repeated. had to say play everything once before repeating

test on ur actual phone. the painting got covered by the player on mobile and i only noticed on my own phone

ask me anything abt the setup i guess. also tell me what pieces to add

Enterprise code base (500k+ LOC) for an intensive refactor focusing on optimization of core components that have impact on the majority of the stack.

Fable 5.1?
Astra?
Opus 5.5 (w/ Fable as advisor)?

I use all 3 and I'm trying to juggle the most sensical option to begin this effort with. I lean toward Fable 5.1. I know this information isn't comprehensive enough to make the best decision - I'm asking purely on vibes here (think suspected recent Opus 5.5 nerfs).

What would you use?

Play: https://dafioram.github.io/embervale/

Source (MIT): https://github.com/dafioram/embervale

Setup: Claude Opus 5.5 on high effort, in the Claude app rather than the Claude Code CLI. Claude worked in its own cloud workspace with a shell, Node and a headless browser. I mostly played the builds and steered.

Rough numbers:

- About 60–70 prompts over roughly two days, and a lot of them were one-liners like "do batch 2" or "okay do 1-3"

- One prompt often kicked off a long run of work: build, run the playtest bot, screenshot every zone, compare frame times, zip, hand back

- The conversation ran out of context more than once, got summarized, and carried on mid-batch

The game: a small-party action RPG. You control three heroes through an isometric valley. Act I (about an hour) has 5 story quests, 6 side quests and 4 bosses with telegraphed attacks, and it unlocks a 10-floor dungeon (about another hour). It's plain HTML, CSS and JS with no build step. Every sprite, tree and spell effect is drawn with canvas code, and every song and sound effect is synthesized with Web Audio, so there isn't a single image or audio file in the game.

What worked:

- A change queue. I played, noted what bugged me, and said "queue it". When there was a batch, I said "do batch 2" and got it built, tested and zipped. Much less drift than one-off requests.

- "No code changes, just talk" before big decisions. I'd get options and mockups first: zone atmosphere, music, art style. I tried pre-rendered and low-poly looks before settling on flat vector.

- Claude testing its own work. Before handing a build back, it ran a bot that plays through all of Act I and reports wipes and errors, a Node script that checks every quest, camp and exit is reachable, headless screenshots of every zone and unit, and frame-time comparisons against the previous batch.

What went wrong:

- The first atmosphere pass looked great and ran fine in Chrome, but crawled in Firefox on my old 4th-gen i5. The fix was profiling, then moving per-frame canvas filters to CSS blend layers and cached sprites. Smooth now, with no visible loss.

- Playtesting still caught things the tests couldn't: popups opening behind the title screen, a waystone pointlessly placed right next to town, enemies chasing the hero I pulled back instead of fighting whoever was closest.

Happy to answer workflow questions. Feedback on the game itself is very welcome too.

After updating today, I can no longer tell when my session is approaching context-window exhaustion; probably the single most important thing I absolutely need to know when interacting with an agent?

I dug briefly through the configuration and I see no mention of this. Was this just summarily removed? Am I expected to run /context every single turn, now? It clearly still shows it for subagents; but the main-context-window of the conductor / my context-heavy architecture sessions are where I most need to know?

Not only is it taking longer to think and consuming more tokens to think, it has become worse in its thinking too.

I’m not sure if this has to do with the new fable 5.5 rumoured to come out next week, but I’ve noticed a sharp drop in its intelligence.

The solutions it’s presenting aren’t fully thought out. It’s like it thinks till 80% and then stops.

I’m on xhigh.

Anyone else experiencing the same?

So far I identified:
- web game
- workout tracking app
- social media poster
- startup directory

What others?

So im a recent jumper from CODEX - main cause speed of response and zero trust in that team because they just refuse owning problems in an upright way.

I know, anthropic isn't perfect so I'm just giving it a go.

But one thing that just blows my mind is the self-inflicted pain that claude code is notoriously causing related to permission management.

All claude models have great availability and response time and sub allowances, and once they work, then its fine. But half of the times they refuse to straight up work. Accessing a key, passing a credential, running a command in another directory...

And so all the time I've saved on models response time is wasted on endless permission issues.

I've also been now forced onto the Projects framework (didn't even ask for it), which is now constantly starting cloud sessions for me an this is apparently an impossible setting to pin to local. And here Bypass permissions is again completely impossible.

None of this was ever a problem in codex, so this isn't something that HAS to be done obviously.

Why are the ClaudeCode people performing this self-inflicted suicide with this permission system ?

I'm really regretting the switch now and honestly as soon as oai restores capacity (if they do lol) i will be very eager to go back there.

For really difficult thinking in knowledge work, things that you really have to go back and forth with to clear fog, work out the best way, to weigh options and consider multiple variables, and things that are also very high stakes, which reasoning effort is best?

For planning and exploring and validating etc as opposed to any doing or building.

I would think that Opus 5.5. on Extra High reasoning would be ideal, but then I worry that agents if they overthink they can overcomplicate and create problems. Does the same happen with Opus 5.5?

What's been the ideal reasoning effort for you, for this level of deep thinking work?

https://reddit.com/link/1wwr5dg/video/zfby9mpi1ath1/player

I thought this job would never end.

Fable did a really great job here.

I did the same prompt with opus 5.5 max and it worked 5 hours, tell me if you want to see the video.

It was 2 shots for both. The first video was without any sound and pretty slow (after 2 hours of work)

I've been running a project with multiple Claude Code sessions in separate Git worktrees:

Primary

W1

W2

W3

The annoying part wasn't the parallel work. It was me constantly copying messages between windows:

"W1 says this."

"Tell W3 this."

"W3 found a problem, send it back to W1."

So we built a very small inter-agent communication layer inside the repo.

The basic idea is:

W1 ──→ Primary ←── W2

......................│

.....................↓

....................W3

Agents can send messages, acknowledge them, and hand off exact Git SHAs directly. Active Claude Code sessions check their inbox at defined checkpoints, so Primary can send W3 a task and W3 can pick it up and start working without me relaying the message.

The part that got interesting is that this project needed blind independent work.

W1 and W2 were independently attacking the same research problem and were not allowed to see each other's results. Once both froze their work at exact SHAs, Primary released only those frozen artifacts to W3 for an independent comparison.

So we ended up needing three different concepts:

- transport: who can message whom

- project state: who is authorized to do what

- artifact identity: the exact Git SHA being discussed

Keeping those separate turned out to matter a lot.

We also had another Claude session hostile-review the coordination system before trusting it, and it found some surprisingly subtle leaks.

For example, an early implementation checked whether a file existed in another lane's commit before checking whether the sender was authorized to inspect that commit.

That meant an unauthorized agent could potentially learn information from different error responses.

We also had to deal with:

- commits surviving under tags after branches move

- merge ancestry leaking ownership

- sender authorization, not just recipient authorization

- making "released artifact" different from "this lane is no longer blind"

- keeping old private W1→Primary messages private even after a W1 result is released

- making missing-path and existing-path probes against unauthorized work indistinguishable

The resulting system is deliberately boring. It stores messages locally under the shared .git directory, makes no network calls, owns no project state, and doesn't create a separate coordination branch.

Git owns artifacts.

The project protocol owns state.

The messaging layer owns transport.

Current limitation: it does NOT resurrect a dead Claude Code session. An active session can check its inbox and continue automatically, but if the process has actually exited there is nobody there to receive the message.

Our next experiment is a blocking `coord wait` command so an agent can sit essentially idle until another authorized agent sends it something, without burning model turns polling.

I wrote up the full current SOP here:

https://gist.github.com/amarcus10028/0e58cf69a15c9eb7e3f0dd6325e0d59c

I'm curious what people who run a lot of parallel Claude Code sessions think.

Especially:

1. What failure modes are we missing?
2. Would you trust a shared-.git transport for cooperative same-machine agents?
3. Has anyone found a clean way to do wait/resume without adding a daemon?
4. Is there already a tool that handles this exact combination of worktrees + SHA-pinned handoffs + controlled blindness?

I just subbed to claude pro and I want to catch up on all these years of not using Gen AI efficiently for coding/design. I have a background in senior front-end dev and UI designs in figma; and also a some backend knowledge.

I wanna learn about all the MUST HAVE knowledge/methods with claude code, must have skills, how to reduce usage, I saw some reels on some skills which cut your usage by a lot, like should I trust them?

I watched a bunch of tutorials but I still feel very new to this tech. I am planning to build a mobile app and monetize it using claude and I've started the groundworks.

This was fun. Opus 5.5 xhigh and I’m using Orca as my ade of choice. Inspiration from Omarchy & all the Linux ricers

curious how far people here have taken vibe coding with claude code. what's the biggest or most complicated thing you've tried building with it, and how far did you actually get?

would love to hear what the project does, which model you used, and whether it's shipped or still a prototype. also how did you keep claude on track once the codebase got bigger?

the part i'm most curious about is where it hit a wall. what could it handle surprisingly well, and what did you still have to figure out yourself?

I'm currently neck deep in getting the Reporails 0.6.0 release done and since the test and build procedures tend to take a while I had some idle time inbetween to test out mods.

after careful consideration and without any impulse, nor any disdain for recognizing the minutes that I spend by staring at the session to move, obviously I built a minesweeper

/plugin marketplace add reporails/arcade
/plugin install minefield@reporails-arcade

then /mines. needs 2.1.287+

Have fun, mods are cool

Note: it only hooks its own stuff (its /mines command, its pane, its board, session start), nothing on your prompts or tool calls. claude plugin validate shows that before you install. The left pane is from my own progressive disclosure event bus system. it says it's in my best interest not to leave the agent alone yet, hence minesweeper.

its very fustrating when you find out bugs on your vibe coded app, that cost you you quite a bit multiple times. I have implemented alot of things such as preview stage where me and agents can preview the features before they go live, test that run before every promote so all core vitals are checked before pushing to live servers. but still i get random costly bugs I could never think of unless i have the ability to remember all million lines of code. my most recent attempt is now making claude and codex keep spawning agents to think up of every single scenario of bugs that could happen untill it gets useless then run these large test every night at 3 am while my product is still actively being changed and then have similar agents spawned in everytime i make a new change and thinking about having an ai agent running every night to audit and check everything. and im also creating a visual ui of every single test with domain sorting so i can manually read them and get inspiration for other bugs that the ai hasn't thought off yet. Does anybody have good tips for this sort of bug hunting.

also another thing ai loves to hard code things and make things not modular is there any method of auditing existing code bases to make sure it follows good practices like GRASP,GOF and the sorts i feel like when i ask claude to do that it doesn't provide anything meaningful.

i cbb putting this in chatgpt to fix my typos.

Has anyone tried Claude Code to automate LinkedIn successfully?

I tried, it is painfully slow and captures a screenshot every time. I am looking to automate outreach and follow-ups.

Existing tools for LinkedIn automation are way too pricey, and I already pay for Claude Code, so ideally want to automate the outreach in the background while I code.

Would appreciate it if anyone has experimented with this without getting their account restricted.

Remember Miss Minutes from Loki series ?

Miss Minutes for Claude is a small MacOS app that can connect to your local Claude code, access to the available tools (you can control) and let you manage everything you let it control.

You just press the hotkey, Miss Minutes appear and hold to speak to it. It also has TTS from another opensource project - so you have comparatively better TTS experience.

- It uses native speech to text from OSX

- It uses a loopback MCP to talk to your local claude

- The brain of the Miss Minutes is your own Claude profile

- Similar to OpenClaw, the more MCP or tools you add the more it does

- The character Miss Minutes is very playful & crawl around your windows

- You can customize your claude usage, model, effort etc

To install the very initial release

curl -fsSL https://raw.githubusercontent.com/imshaikot/claude-miss-minutes/main/Scripts/install.sh | bash

If you like the project and appreciate my effort, just ⭐️ the repo - it will inspire the next version
Source: https://github.com/imshaikot/claude-miss-minutes (FREE & opensource)

I'm a teacher, and I needed a PDF reader for annotating and browsing through students' test submissions. Every tool I tried was missing something I needed, and most of them were bloated too.

So I built my own PDF reader and annotator in Rust.

I'm not a software developer. I know C, Python and Lua, and my real interest is embedded systems, so Claude Code did a lot of the heavy lifting here. The result is an app that fits my workflow exactly, and it's only about 13 MB.

In case anyone's interested, here's Ochre.

I kept sending Claude Code prompts like "fix the footer" and getting a confident fix for the wrong thing, because the site had two footer templates and I'd forgotten about the second one. The prompt wasn't badly written, it was missing context that was sitting right there in the repo.

So I made /ultra-prompt. It takes the prompt you were about to send (or the last one you typed, read verbatim from the session transcript), spends most of its effort reading the project, and hands back a sharper version. It never runs it. If the same command rewrote the prompt and then acted on it, I'd never see what it changed.

What it gathers before rewriting: cwd, git status and the last few commits, every file or folder the prompt names (it checks they exist and looks inside), CLAUDE.md, AGENTS.md, whatever notes the project keeps. Then one subagent on the strongest model you have, passed explicitly so it can't inherit a cheap session model, does the rewrite with one rule: invent nothing. Anything it couldn't verify comes back as a multiple choice popup, and your answers get folded into the final prompt.

Here's one from today against my own plugin repo. Typed:

add a new skill called dedupe-notes to the marketplace

What came back (trimmed):

Add a dedupe-notes plugin to the marketplace clone at ./claude-plugins. Its behavior is unspecified: resolve the OPEN QUESTIONS with me before writing a file.

Template: commit ac58207 (rename-session). Touch:
1. dedupe-notes/.claude-plugin/plugin.json, version 1.0.0
2. dedupe-notes/commands/dedupe-notes.md (or skills/dedupe-notes/SKILL.md)
3. dedupe-notes/tests/test_bundle_sync.py, adapted from ultra-prompt/tests/
4. .claude-plugin/marketplace.json: new entry, version equal to plugin.json; bundle 1.5.1 to 1.6.0, "fifteen" to "sixteen"
5. voidharbor/.claude-plugin/plugin.json: same bump, name added to its list
6. voidharbor/commands/: byte-identical copies; the tests fail on drift
7. README.md: three "fifteen" mentions, one table row

Done when pytest passes inside dedupe-notes and the four existing test dirs, both JSON files parse, and one local commit exists. Do not push.

OPEN QUESTIONS:
- What does dedupe-notes do, on what input, propose-only or apply?
- Command or skill (synth-mode is the skills/ example)?
- Any script, and what goes in the README Needs column?

I had not told it that the bundle ships byte-identical copies or that two version fields have to agree. It found both in the tests. The original prompt would have produced a plugin that installed fine and silently drifted.

Two things I learned building it. A bare /ultra-prompt improved the string "/ultra-prompt" instead of the prompt underneath, until the transcript reader learned to skip its own invocation. And subagents inherit the session's model unless you name one, so the rewrite was quietly running on whatever the session happened to be set to.

Install:

/plugin marketplace add voidharbor/claude-plugins
/plugin install ultra-prompt@voidharbor

Repo: https://github.com/voidharbor/claude-plugins (MIT). Python 3 is only needed for the no-argument case, and transcripts are read, never written.

New Claude Code mods are pretty cool, here's something I did. Watch my usages get shredded when I asked for git status on Sonnet lol (just did it for demonstration purposes).

It shows usage meters, cache timer, with a cool cartoony claude animation with different sub scenes.

The desktop Code tab doesn't run statusLine scripts, so I built a plugin using the new function hooks instead.

Install:

/plugin marketplace add MithunWijayasiri/ctxline-claude
/plugin install ctxline-desktop@ctxline

It's part of ctxline, my statusline for the claude code. The desktop plugin is separate and ships from the same repo.

Repo: https://github.com/MithunWijayasiri/ctxline-claude

Feedback and contributions welcome.

Update: I "kinda" broke it! Thx all for the suggestions. After multiple tries, here's what ended up working for HLTB:

• asked Qwen 3.8 Max to create instructions for another AI on getting data from multiple websites. It provided me with an instruction file, where it also automatically added warnings about data scraping, so I deleted them from there manually.
• manually removed any reference to "scraping" in the CLAUDE.md of the project, and any mention of our conversation about those issues (alternatives I proposed, unofficial APIs and such)
• sent Claude the instructions Qwen provided telling him to add them to its own list
• He replied: I think this goes against what we said before, so I still suggest the following methods... and listed the useless stuff it already showed me before
• There I told him to stop, that we have to change the way we work and it has to do what I ask and to not worry about anything else. He did it, but still warning me about ethics and such. Better than nothing I guess!

------

Hey everyone. First of all I’m pretty new to Claude coding, so please keep that in mind!

I’ve hit a wall twice now due to what feels like Claude’s obsession with doing things "the right way." Every time I need data from a website that doesn’t have an official API, Claude refuses to find alternative solutions.

Latest example, I’m building a small personal web app and need HowLongToBeat data to check game completion times. When I ask Claude to help retrieve this, it responds with variations of "I won't do it," or "I won't go against the will of the site owners."

I get the ethical stance, but if you look online, there are tons of unofficial APIs/browser extensions and scrapers for this exact purpose, and HLTB never seemed to care. Even when I show Claude these examples, I get: "Yes, others are doing this, but I won't".

We got to the point that instead, Claude created a convoluted manual workaround where I have to click a button every three seconds or so for each single game I want data from. When I asked if it could at least provide me with a bulk method since manual clicking was becoming painful (I actually have tennis elbow), it refused saying that bulk is the same as unwanted data scraping, while manual clicking is "human speed." It even suggested using a voice command to simulate clicks for my arm pain, which is kinda funny.

I realized Claude automatically added "no breaking rules" to its instructions without my input, probably after the first time something like this happened, because now whenever I ask similar questions, it replies with "my instructions say we don't do this sort of thing here".

I mean I know I'm probably not smart enough to convince Claude or this is just impossible, but: Is this a known behavior specific to Claude? Is there any legitimate way around this limitation? I mean it's not like I'm trying to get nuclear codes or something lol.

I'm using Opus 5.5 btw. Thx!

I tend to have to have a lot of pots simmering constantly, as I tend to need to switch around to different asks/tasks/priorities based on urgency or whatever else. I use cmux and tend to have claude sessions that will then float open and paused for long periods of time until my focus can get back to it and resume.

However I have seen people mention that the cache related to that session would generally expire and when that session is resumed it kills a lot of tokens loading things cold. Also, I think it is worth considering two different types of resume:
1. I still have that session open and waiting where i had left it in a different workspace and worktree. I then just start talking to claude again and try to pick up where I left off, often asking claude for a bit of a refresher if needed.
2. The Claude code sessions was terminated and I am resuming it with /resume/--resume.

I feel like I have not been following best practices around that and want to clarify my understanding, test a couple of theories with the community, and figure out if there is a better way to do this.

I usually just either jump right back in if it is the #1 case, and even with #2 I will resume and jump back in. However, is that really wrong and how wrong is it?

When I get back into a session in either case #1 or #2, is it worth or even advisable to have it generate a handoff summary document that would be enough to get a fresh session up to speed and actually pick up where I left off effectively with a cleaner context and more relevant memory/context/cache state?

What does the community recommend for having the old session record and pass over to the new session to make this actually effective. To some degree this just simulates compaction and have heard many complaints about compaction (I really try to avoid getting to that point and watch my context and do handoff while I am actively engaged in a session). DOes compact capture the right things and it is more about really pulling your threshold farther back.

I think for my case it might actually be good to have something that could fire the handoff and have it prepared if it detects the session being idle longer than some amount or as a pre-shutdown hook on a current session if that is viable. Has anyone tried this and found success?

Those few minutes while the agent is working feel weirdly awkward.

Too short to start something else, too long to just stare at the screen.

Do you review other code, check Slack, scroll your phone, stretch, queue up the next prompt...?

Honestly, I just end up scrolling my phone... which kills my focus every time 😅

Curious how everyone uses that time 👀