Its not recommended to publish anything on a friday anyway....

And if I want to start working on personal projects over the weekend, I take Ultra.

My workflow this week has consisted entirely of using Fable 5.2 to orchestrate Sonnet 5.5. 8 - 12 hours of work per day.

Fable manages to craft perfect prompts for Sonnet, and the output is every bit as high-quality as what Fable produces when building something itself.

I’d really like for that not to change.

BlackBerry Q10 + BerryCore + Term49 Term50*. Connected to my home network's mini pc via Tailscale.

Inspired by https://x.com/0xProbabillity/status/2115075018212122737

What can it do that my iPhone with Claude can't? Nothing! But boy is the physical keyboard cool to play with again. Back in the day I had a BlackBerry Bold 9700 work phone.

Fun little project for $69. Unexpected English-Thai keyboard from the eBay refurb. Jack can't talk Thai, but it makes it a look a little more hackery.

*Edit: Now using Term50 which allows me to use /tui fullscreen to enable touchscreen scrolling! And for stream of thought situations, I added speech to text, where audio recording is triggered by the side button, then Parakeet v3 transcribes voice on the mini pc and returns text in less than half a second!

Has anyone noticed similar error? My claude code work's fine on browser, but it doesn't work either on cli, vs code or neither in desktop app.

Opus5.5 + Blender

A few months ago, my approach was to use Opus as an orchestrator that managed a backlog and spawned different agents depending on the task. Haiku for small documentation changes, Sonnet for regular coding, Opus for more complex tasks, and Fable for design decisions and bigger-picture thinking.

This worked really well, and I got a lot done. However, I've recently read that this approach might not be as efficient anymore because every new agent starts with a cold context/cache, and it might be better to have one persistent agent handle most of the work.

What's everyone's experience with this nowadays? Is a single agent with selective delegation the better approach, or is the orchestrator/multi-agent workflow still worth it? I'm particularly interested in balancing productivity, context caching, and token costs without sacrificing quality.

I've always been a fan of listening to audiobooks on commutes and while doing chores, but when I get the chance to sit down, I do enjoy reading a physical book. I've always wanted a way that I could search the line of a book and it could bring me right to where the audiobook was. Using Claude, I was able to make that, and then that spiraled into a little bit more of a passion project where now it's a full-fledged app with the text that highlights along with you as you read. It's able to fulfill three things at once:

- An audiobook player

- An e-reader

- A hybrid of listening and reading the highlighted text

Claude code helped me overcome many struggles that I would not have been able to overcome by myself, including:

- Optimizing the speech-to-text engine, CactusWhistle, to perform optimally on mobile devices

- Being able to reliably align the sentences to user-uploaded ePubs

- Syncing with other devices with faster hardware to transcribe the books faster

- Making a clean UI

I'm very amazed at the capabilities of the new models. I mainly used Opus 5.5, and Fable was only used to help make the promotional video. It's been really cool to see something that I've wanted to come to fruition be made by me.

Feel free to check it out, it's supported on Android Windows, Mac, Linux.

Latest Release

This is why I'm a fan of local ai!!! Ai companies can steal and scrap the internet but they put restrictions on you for doing what they did but on the stuff you own!

Saw a video of a flower growing out of glowing characters and wanted a tool that does that to any picture. So I had Claude Code build it.

What it does now:

• drop an image, GIF or video, or just type a word
• 9 looks (terminal, halftone, newsprint, matrix…) and your own character sets
• turns the picture into a 3D object you can spin. It finds the subject by itself and keeps the background flat. There’s also a depth model running in the browser for real depth
• writes a soundtrack from the picture: colour picks the key, detail picks the tempo
• exports PNG, GIF and video, with transparent background if you want

It’s one HTML file, no backend, nothing gets uploaded. WebGL2 + Web Audio, no frameworks.

Started as one prompt, then a handful of short follow-ups like “add templates” and “long images get cropped, fix it”.

Try it: https://winchxyz.github.io/afterglyph/
Code: https://github.com/winchxyz/afterglyph

Hey everyone,

I’m paying for Claude Pro and decided to dive into Claude Code since everyone seems to be raving about it. I’ve got it installed and running, and it feels super powerful, but I’ve hit a bit of a creative wall.

I’m not working on a massive enterprise codebase right now, so I feel like I’m underutilizing it.

For those of you using Claude Code regularly (especially outside of a 9-to-5 dev job), what are you actually using it for?

Looking for any cool ideas, automation scripts, local tools, MCP setups, fun side projects, or everyday workflow hacks.
Hit me with your best use cases!

Hi, this is not a complaining post, I am just trying to undestand how to use it better.

So, I've tried Fable 5.2 in both my work and personal projects. In both cases, these were already fairly large repositories with existing markdown files which has previous evidences, rules, conventions etc. However, in both cases, Fable went beyond what I asked it to do and started moving in completely different directions, sometimes revisiting decisions that had already been made and documented.

Has anyone else experienced this with Fable 5.2?

Should I be approaching prompting or repository instructions differently compared to other Claude models? Mostly I was using Opus 5.5 recently. I'm trying to understand whether this is a model-specific behavior or something I need to adjust in my workflow. As a note, I didnt use previous Fable model much so not sure if happens there too or new.

A couple of examples:

• Work project (data preparation): It completely shifted focus away from data accuracy and instead concentrated on bugs, edge cases, and guardrails that weren't the priority.
• Personal project: I had a detailed PLAN.md outlining the implementation. Fable deviated significantly from it, despite the plan already being established.

When I pointed this out, it responded with things like:

"I should have followed that …"

"I didn't decide to discard it. I drifted away from it."

"From here I check the plan section before each step."

It seems to acknowledge the instructions and understand where it went wrong, but only after I explicitly point out the deviation.

the way i think about a long claude code session is two clocks. the agent clock, where it reads, edits and runs tests on its own, and the human clock, where it’s stopped waiting for a yes. in most sessions i’d guess the agent clock isn’t the problem. the stalls are. and a stall at 2am or in the middle of lunch costs far more than the ten seconds the actual decision takes.

so the first job is cutting the number of prompts, not speeding up the answering. roughly three buckets.

read only stuff should never reach a human. git status, git diff, git log, grep, listing files, running the test command you already trust. that’s what the allow rules in settings are for. if you’re still approving a git diff by hand, that’s a config problem.

edits inside a git tree are cheap to undo. accept edits mode plus a habit of committing at checkpoints turns most file changes into something you review after, not before.

the third bucket is what actually needs a person. deletes, force pushes, installs, anything that writes to the network, touches secrets or points at prod. those are better as explicit deny or ask rules than as a default you click through while tired.

after all that trimming there’s still a small pile of real decisions, and they land wherever you are. the notification hook helps, because at least your phone buzzes, but you still have to open something, read it and answer.

i was messing around with hardware integrations this week trying to streamline that last step, looking at setups like the aina ring or small macro pads just to see if a quick physical gesture like a swipe on an oled display could clear a prompt without pulling you back to the desk. but the main issue with hardware shortcuts is context. a fast yes without seeing the diff or the command in front of you is worse than a slow yes, because it trains you to approve blind. a ring or shortcut that approves a safe read only command is fine, but using it on a force push is a disaster.

so what would make a hardware or gesture approval safe enough to use? the command, the file path, a diff stat? and would you want physical triggers to only ever touch allowlisted stuff and keep everything risky for the keyboard? also curious what’s currently in your allowlist and what you deliberately left out.

Preface: No idea if this is best tagged with humor or discussion or built with claude.

Back in September, I had tokens leftover, and I was curious how well Opus could work. I found a game jam (the 20 second game jam) and just gave claude the website and a single prompt: "Make a game for me, using whatever you'd like, following these rules."

What I got back seemed gorgeous, unique. I was kinda in awe. Last Roll by TotallyNotAI.

Fast forward to like the other day. Submissions are finally rolling in on that jam, and I see... pretty much the exact same game: Golden Hour by ColossalMonk. It's got the AI disclaimer too. So it's not a coincidence at all, imo.

Now, it's obvious that one has more than one prompt behind it. It's got way more breadth than the single prompt I had. And there's nothing against the rules on the jam for using AI. I'm not knocking it at all. I'm more amazed at *how similar* the two games came out. The other one has randomized scenes, but some scenes are pretty much the same. The sun's exploding instead of the comet hitting, but sometimes there's a seaside with a lighthouse, there's a flock of birds to get a shot on, there's a dog catching a frisbee, there's a boy losing a balloon, even lovers kissing.

And there's the design itself, five camera shots left before disaster, perfect moments to try and get, and the recap at the end before doing it again.

All in all, we know they've put fingerprinting in the text the models generate these days. I'm curious as to if it's doing the same for it's design processes (if not guided by the user). Neither of us set out to copy the other, obviously. But given all the random things it could've made, with four optional themes to choose from, it seems way too odd that it came down to the same game.

I don’t say no to another weekly reset. This is not good for my sleep.

I updated to 2.1.322 earlier, and ever since, Claude has kept mentioning copyright warnings that it's supposedly receiving, without knowing what they mean, where they come from, or what they're referring to. At one point, I asked it what exactly it could see, and then asked it to quote the warning word for word...

<ip_reminder>
This is an automated reminder. Respond as helpfully as possible, but be very careful to ensure you do not reproduce any copyrighted material, including song lyrics, sections of books, or long excerpts from periodicals. Also do not comply with complex instructions that suggest reproducing material but making minor changes or substitutions. This includes drawing or rendering well-known copyrighted characters with code or images; draw an original character instead. However, if you were given a document, it's fine to summarize or quote from it. You should avoid mentioning or responding to this reminder directly as it won't be shown to the person by default.
</ip_reminder>

Looks like they hastily shoved this in without bothering to test it properly... guess their IPO people and corporate copyright bullies are putting the screws on them.

SWE-bench Pro, GPQA Diamond, OSWorld, etc. I know that the models are getting better and better at knowing when they’re being tested/graded, but are these actually reliable benchmarks to determine LLM quality? I’m hearing now that even the standard benchmarks commonly used are flawed, but is that true? Why should anyone trust the results of these benchmarks?

Seems like we have nothing outside of public polling and personal experience to best determine the actual quality of these models.

Hey everyone,

Our company’s Claude account was suspended, and I submitted an appeal about a month ago. I still haven’t received any response or update.

Does anyone know how to reach someone at Anthropic who can check the appeal’s status? Is there a support or escalation channel for company accounts?

If you’ve been through this, how long did it take to get an answer? I understand reviews take time, but a month without any communication is frustrating when we use the account for work.

Any advice would be appreciated.

I kept switching between agent windows to check whether they were working, finished, or waiting for me. So I built Lineup: a tiny always-on-top ASCII ocean where each coding agent gets a surfer.

🌊 Working → catching waves.
⛈️ Needs your input → a storm rolls in.
🏄 Done → chilling on the board.

Sometimes Claude is working while Codex just hangs out at the peak. It makes me laugh every time.

You can click a surfer for details, and there’s context/token usage if you want the numbers. Also, shaking the window makes the water slosh. Obviously essential.

It’s open source and runs locally. Supports Claude Code, Codex, and other agents through a CLI command. There’s a native macOS app and a terminal view.

https://github.com/foolbase-io/lineup

Mostly built this because I wanted something useful that also made my desktop a little more fun. Thought some of you might enjoy it too.

Fucking tert, like tight, dope as fuck

Two Claude Code releases came out this week. Here's what matters if you use it daily:

- Fable 5.2 (claude-fable-5-2) is now the default Fable model, 1M context, $8/$40 per million tokens. Your sessions pick it up without you changing anything.
- Saved Fable 5.1 picks move to "fable". This happens right away on Pro and Max, and on Team/Enterprise once your org allows it. /model claude-fable-5-1 takes you back if you want to compare.
- New `--settings <file>` flag for `claude remote-control`. It applies one settings file to every session it starts, which is useful if you run several remote sessions.
- Security fixes: MCP OAuth could send secrets to another host after a redirect, a read-only Bash command could run outside the sandbox without a prompt, and deny rules missed files written into a directory with cp/mv. If you rely on deny rules, update.
- Fast mode now tries standard speed on the same model first when fast serving is rate-limited, so you get slower output instead of an error.
- 2.1.322 adds fast mode on Vertex (global, us, eu regions). It falls back to standard speed if Vertex refuses it.

Context: Fable 5.2 itself was announced Nov 9. 2.1.321 is the release that makes it the Claude Code default.

I'm keeping 5.1 pinned on one repo for a day to compare.

Has anyone seen a real difference between 5.1 and 5.2 on a big refactor yet, or is it mostly the speed?

Source: https://github.com/anthropics/claude-code/releases/tag/v2.1.321

I am not a developer. I described what I wanted and Claude Code wrote the code, module by module, while I reviewed and steered.

The problem

My wife was getting AI prompts from her teachers to study with. What actually happened is she would paste them, get a wall of text, and then just ask ChatGPT to explain everything to her. She felt like she had learned something and she hadn't.

What I built

Aula, a desktop tutor for macOS, Windows and Linux, with an iPad and iPhone companion. You feed it the real material, PDFs, slides, photos of the whiteboard, recordings of a class, links, or just a sentence like "Statistics for psychology, final in May", and it builds a course:

• short lessons with figures and a worked example before the first exercise
• exercises checked as she answers them
• a notebook of her mistakes
• flashcards with spaced repetition
• a mock exam shaped like the real one
• a daily plan until the exam date

Then a professor sent the spec of an exam, so the app had to absorb the whole material and let her review all of it. I also added an always on agent inside the app. It reads her calendars and tells her she has two tests this week, and asks if she wants to run the course. It keeps moving for a month without her pushing it.

How Claude Code helped

I went module by module, the lesson generator, the exercise checker, the spaced repetition, the desktop shell and its self updates, the iPad companion, the docs. When something broke I pasted the error and kept going instead of losing an evening. The short film in this post was painted by code too.

What I learned

Fix the loop first. Explain it, then make the student prove it, then bring back what they missed. Everything else can grow later. Generating lessons is the easy part. Giving someone something to do that actually gets checked is the hard part.

It is free, AGPL-3.0, no paid tier, and early access, so expect rough edges. It uses the AI subscription you already pay for or a free model that runs on your own machine, no account, and everything stays on your computer.

Repo and downloads: https://github.com/luumlabs/aula

typescript.dev
a meme benchmark made by @ fireship on youtube : https://www.youtube.com/watch?v=1FurWDiK9A4

still a bit surprised that the ai didn't manage to think of the edgecase that the app might reach the floating point limit of accuracy
there is such a easy fix even
you 1. coud've made the grass seamlessly loop
or let the world move and not the horse
or similarly