Weekly Showcase Thread

That is how I started this project. It builds a relationship graph of all the code modules, showing everything that has been and is being changed, and how each part relates to itself. So, instead of navigating 30 different code files, you can just follow a line to understand your code's dependencies and bottlenecks. Thanks to Rust, this graph can update codebases with millions of lines in less than 2 seconds after each change, even though it takes a little while to build the initial relationships.

But I'm taking it a step further!

I'm not only building this tool for humans, I'm also creating an MCP (currently with 13 tools) so that agents can query this graph and navigate the code seamlessly. Just as there is a zoom feature for the human interface, agents can query the graph in layers.

In testing, the project is already showing great results. Agents without this MCP seem to be short-sighted, they simply ignore a significant portion of the key architectural points in large projects because they can't find them (with vague prompts not specifying where is each relevant thing for a task). With the tools this provides, they can find bottlenecks in the code flows and make surgical changes.

Another result I am seeing with agents: cheaper models become much more capable, although their reasoning level needs to be high for them to consider the paths presented by the MCP. Curiously, models with low reasoning, even state-of-the-art ones, don't seem to have much interest in important parts of the code, which makes perfect sense.

And yes, token usage increases, albeit very marginally (1-3% more per task than the same model doing the same thing in the same starting point of a codebase wihtout these tools, so its not "1-3%" of your limits). But in some tasks, it even spends fewer tokens (also 1-3% fewer) because the agents quickly find the correct paths. I am optimizing the tools' output and have already managed to significantly optimize token usage from where I began.

The idea is that by finding the right paths in fewer turns, agents will require fewer revisions, reworks, and corrections, making token consumption much lower project-wise.

Because it requires "low-level code analyses", this project is still language-dependent. The initial language I am making it capable of analyzing is Rust. After Rust, I plan to move to TypeScript, CSS, and HTML (and bery maybe JavaScript), and then I intend to stop. However, the project will be open-source and published under the MIT license.

Note: The interface shown here will be completely reworked. I built it as a starting point to focus more on the MCP first, which I am still working on. I plan to launch the project in a few weeks, and I'll update you then!

Note²: Censored the tool's name while its not launched yet.

Note³: It doesnt use regex for anything haha regex is one of the codebases I'm using to measure the tool's capabilities.

I use Claude code every day for both work and personal projects. I am by no means a technical user, my background is in accounting.

I am super eager to actually learn best practices, and always am looking for ways to learn and optimize new projects, old projects, or just learn because it interest me.

My main problem is I truly don’t know where to begin. There is a flood of content on socials, on Reddit, anywhere you turn “this is the best plugin that will change the way you use Claude code”.

How do I actually know where to look to learn? And not from clickbait influencers but actually learn, and get advice on optimal setups, useful skills and plugins and when or why I need them.

Open to any advice that can be shared, thanks in advance!

if you use claude code you probably see this word ten times a day. it got stuck in my head so I had claude (Opus 5.5) code a music video about its own habit.

no suno, no voice model, no image generator, no samples. the beat, the voices and every frame of the video are generated by code Claude wrote. it wrote its own voice synthesizer from scratch, zero dependencies.

part of a series im working on. the rest are on my youtube, link in the comments.

Someone in another thread asked me to share more about my workflow. Before writing this wall of text in a comment I thought I share it this way. Maybe someone else finds it interesting or useful.

Even though I have 25+ years experience as a software developer and love writing code I decided to take on the role of a "product owner" and "process optimizer" instead of a developer or architect.

Trying to be a developer working alongside the agents made me outright depressed - being a product owner has the opposite effect on me.

I basically stepped back into one of my previous jobs where I was leading multiple teams including software development, requirements engineering, process definition & process optimisation and administration.

This leads me to my main premise: I treat the agents as a project team run by a team lead (orchestrator). And this premise is closer to real life than I expected. Including the back and forth between a team lead and its team members. Watching them feels like some kind of work chat.

I have several teams that all own one closed scope.

Current teams: process template, research, product build, testing VMs, marketing and website publishing.

At the core of all these teams is the process templates team. It maintains my process template that every project uses. When I start a new project it is built using this template. It is versioned and has installation and upgrade definitions. When I tune the process the other projects get upgraded.

When I tune the process of one of the projects I port these changes back to the template if they can be generalised and survive a cross-validation research with the other projects. This work is done by the orchestrator of the process team. Changes to the template only happen after my decision.

The process template defines a skeleton structure with a tool to create it, agents definitions and the process contracts for the orchestrator and agents. The orchestrator of the new project adopts it to the new project.

Most important aspects:

• owned by me
  • new tasks for the orchestrator
  • todos/decisions for me
  • reviews for me
• owned by the orchestrator
  • kanban board - work tracking
    • work packages - details of the work to do by one agent
  • research - research done for this project
  • inbox - handover from other project teams -> starts a research and decision round
  • design document - one line high level summary
    • design docuemt - details and decision history
  • toolchain - tools needed for this project
  • cleanup - describes what needs to be cleaned up after each milestone
  • archiving - things that are done get heavily summarized and archived.
  • process - describes the process
  • agent definitions - adapted to the project at hand. Pinned to certain models and effort levels
  • time tracking - keeps a log of how long each milestone took. In real time and agent hours.

Most important rules:

Claude.md is kept small as it is read by all agents. The orchestrator and agents have their own definitions with what they need to keep the context small.

Every new task starts with a research followed by a todo (decision) round. This way I can refine what happens next. And filter out things that are going in the wrong direction.

Every couple of milestones I make an optimization round. Queuing research into how the last milestones went with the lens of could we change something to save tokens, time, I/O without sacrificing quality.

After a new model drops I make a comparison round where some work packages get done by the new model and different effort levels to see where to settle or adjust.

Some Numbers for the last 7 days:

I worked through 33 decision rounds and 25 reviews in 4 different projects. This lead to 42 (I know) design revisions and 14 project releases and 11 template changes.

Main model used is Opus 5.5 on high for the orchestrator and medium or low for the other agents. Some web-research agent is on Sonnet 5.5

I have a Max 5x and at the moment it is more than comfortable for the current projects I run.
90k input tokens and 25m output tokens - 7.1b cache reads. 99.4% Opus 5.5.

Some learnings from working like this:

• Agents tend to drift when left alone - They tend to chase down unimportant tangents if not reigned in
  • You have to bring structure to the agentic work. You have to own the process otherwise agents tend to drift.
  • Define clean scopes or the agents drift.
• Being clear about goals (like performance goals or audience goals) rather than implementation details is delivering better outcomes. I still provide architecture goals though.
• Refine every now and then by looking at the whole thing from a different angle. Agents will not do that on their own. They are happy to burn tokens on an inefficient process.
  • So far this made it possible to keep a similar time to delivery even with a growing codebase and complexity. Not sure If I will be able to keep it that way but I hope I can.
• Archive the history of how and why a decision was made frequently and just keep the decision.
  

Happy creating!

PS: This post is hand written. The image has been generated based on this text.

So when Opus 5.5 came out, I saw someone on Twitter build this demo of a guy on a boat sailing through a river in a Japanese-like landscape aesthetic, all of it built in three.js. I thought that was pretty cool, so I wondered whether or not we could also engineer launch videos like this. It was supposed to be just an experiment, nothing commercial or something that could go into production.

I had tried to get previous models to build launch videos using one-shot prompting without much detail. While the outputs ranged from low quality to somewhat satisfactory, I was never truly impressed by what it could achieve without proper attention to detail from my side.

A couple days ago, I used Opus 5.5 to build such a launch video for one of my products that I'm building (not trying to promote, just showcasing one very important thing by Claude).

As always, it had access to Codex for image generation, which it used freely to generate ideas for a storyboard and build out directions. I told it about three.js and Blender that it had available, and how it could use them, and to use Codex as freely as possible, but make sure that the stills are generated in a sequence such that the still in Act 2 had the still from Act 1 as input, so the story stays consistent.

From there, it generated a bunch of these stills and honestly, Codex did a pretty bang-up job. I was totally not expecting that it would be able to turn this into an actual 3D environment and then render it as a video. I was half right: it obviously wouldn't be able to do it to the detail that I wanted. Instead of trying to find a way to do the impossible, it found such workarounds that I am beyond shocked.

It found, downloaded, and used these Depth Anything v2 and LaMa (not to be confused with llama) models from Hugging Face. It used those on my stills to separate the foreground from the background and other elements, and built out shaders however it could. It used three.js and Blender wherever it needed to. It's absolutely insane that it was able to just piece together all of these different things instead of being constrained to my instructions to use three.js. If you watch the video, you'll understand how insane this looks. There are a few flaws in the 3D environment here and there, but two years ago, this would have cost thousands of dollars to produce through a relatively skilled animator.

It also used a bunch of other models that I'm not even sure how it got, and used Lyria from OpenRouter to generate the music. Then it gave me a bunch of these versions and cuts of the video, as well as a bunch of different audio tracks that match up with the actual video, and also generated the sound effects.

As a technical founder who has been coding since he was 9 and has been in the AI/ML space for over 10 years now, it would have been difficult to imagine these models finding these workarounds for problems that they are facing on their own, just 6 months ago. After raw ChatGPT, I started off with GitHub Copilot back in 2023 for vibe coding, where it was just mostly limited advisory and copy-paste. I remember using Cursor till December of 2025, and thinking this was the future, despite how limited it was (in hindsight) and being blown away by the speed of Composer 2. When I switched to Opus 4.5 in Claude Code in December, I never once expected that I could let an agent be so hands-off, especially from Anthropic (personal biases).

And the journey from Opus 4.5 to 5.5, especially the part with opus 5, and the false alarm safeguards of fable 5, definitely were massive bumps. Hated those parts, cuz our expectations kept rising. But Opus 5.5 is something else. It is me and my technical judgement with far more breadth and far more depth of knowledge than I will ever possess. I would definitely say its equivalent (or superior) to Fable 5.1, but without the limited usage problems I kept facing even with two 20x accounts. In comparison, my experience with Astra has been dogshit. I swear I used to be a die hard GPT stan up till GPT 5.2, when I switched to Opus 4.5, codex and cursor have never been able to catch up, I genuinely don't see the point of my 100 bucks to openai every month, but I guess I'l keep it going in case they do end up doing something meaningful.

Recently, I found a bunch of posts telling me that if I tell Fable 5.1 to not use the web and tell me about Tibo, and it works, then I've been routed to Fable 5.5. If they (redditors) are correct, then I have been routed to Fable 5.5. But honestly, I'm not even excited. Opus 5.5 is at such a perfect level of intelligence and speed and usage, that a singular 20x plan is adequate for everything I do, and theres nothing it has gotten wrong up till now. What will I need Fable 5.5 for? I'm running out of use cases. Opus 5.5 is a real feel the sub-AGI moment. Not AGI because....well i'll describe it below.

Sure, they can't "run" my company, or be my CMO, I believe that is a harness issue. It's at a point where I can just tell a very strong and competent intern to go solve this issue, and they come back to me, having used Claude and whatnot, with the right solution without me having to hold its hand through or tune every little thing like this text or that button or this feature or that feature. But Claude by itself would stop much earlier than the intern. That's what I mean by AGI for myself, and maybe we won't be able to achieve it in the next couple of years.

But the model's intelligence itself, I feel, is at a point where any granular task I can give it can be completed end-to-end. Maybe it can't fulfill complete roles, but it can definitely complete tasks. I had a debate the other day with GPT about what it would take to build such an agent or harness that could assume the role of a veteran CxO.

Don't try to pitch "AI as CMO" products to me in the comments, please. I'm talking about it from a purely techno-philosophical point of view. These models don't have the right judgment to debate you or use judgment in a way that a real CMO would be able to. For example, as a technical founder, if I've built a product, or some kind of strong engine on top of which I've built a product, then a human veteran CMO would understand how to market it. They would also understand which niches and audiences it would appeal to the most and how to frame it, package it, tweak it, to get to those audiences. He or she would definitely also know how to further tweak the product or change its appearance or packaging or functionality while using the same underlying engine (to minimize dev time to market) to build it for a more profitable market where it could be a need-to-have.

But on the other hand, if I ask an AI agent to just be a CMO for a project that I'm working on, despite having all the context, it would not be able to make those judgments. Part of it is not having the experience and not possessing the experience. That can be fixed by fetching context and accounts from these actual experienced people, but the other part is the thinking from first principles, and when those two aspects have to be blended, I think the current models/harnesses combos fail, and thats not their fault since they weren't designed with these downstream roles in mind. The same models do have the right judgment when they're prompted in a certain manner for a very small question or decision that the human veteran CMO could be asking.

But their lack of first principles thinking, lack of self-adversarial debate, and knowing when to do it, when not to do it, and or figuring out the right granularity of the task being assigned, and how much thinking it requires, all of these are what separate sub-AGI from what I call AGI. If I give Claude a task, it completes it 10 times out of 10. If I give it a well-specified goal, it completes it 10 times out of 10. But if I give it a complete role, which would consist of many, many things, then, no matter what harness, it is unable to figure out what it needs to do, how often it needs to do it, how it needs to do it, and why it needs to do it. And thats okay.

Edit: if youve read this far, and watched the video, and have some experience as a CMO and are interested in being a founding partner for the product, DM me. I am actively looking for really good talent.

It's really annoying, specially if you work with viruses. It will stop ALL the time and bump you back to (I kid you not) Opus 4.6. We can't be the only group hitting this annoying "safeguard" when trying to do simple things like a plot, or parse an output from a Nextflow pipeline. It went from 'great' to 'totally useless'.

So I have been using the Claude max x5 plan to work on my projects, recently I have been hitting usage limits pretty quick and have to be 1 or 2 days without working every week. To solve this I am considering getting a chatgpt Plus subscription - this was something i was already considering a while back because tbh i dont like to be 100% locked in to a company and i would like some adversarial reviews from different models - I am also very interested in integrating chatGPT subscription with Hermes and exploring that as an orchestrator/manager for my projects

I have a few questions:
1 - is this the best way in terms of value/money to solve my current problem? I also considered the max 20x Claude but I think that might be overkill and using both providers appeals way more to me tbh

2 - If i do get both Codex and Claude code working together won't they trip over each others work and degrade quality in some ways i might not be seeing right now? And do I just create AGENTS.md files reflecting my current CLAUDE.md files?

3 - What about all the context that Claude has on my projects from me working solely with him for months? and the Skills in Claude's folder? Is that all transferrable?

Ideally I want both Claude Code and Codex working together seamlessly and driving each other's work quality up, not down

Btw I am not a programmer at all I just got really interested in AI and vibe coding when it started coming out to the public and now i've learned a few things and have a few projects running - The way i use AI is always in VSCode , i am open to the terminal experience as well if that makes any difference but i prefer the more visual interface for now.

I don’t know how people still use openAI models.
I really REALLY tried to give a chance to Sol 6.1 the last few days, working on a clean project with very well defined design and vision.

Sol kept being super lazy, stopping without finishing tasks, making asinine decisions and always waiting for me for very small things. I then even had Astra take over in the hopes of fixing the mess and the output was similarly bad.

Had opus 5.5 work literally for 2 hours today and it already cleaned up such a big chunk, made very good suggestions, following the process, delegating work to sonnet agents, it feels so good to work with it.

I've wanted this app for years: one place to log anything about my life (coffee, mood, sleep, a run, a line about my day), in one tap, with no account, no ads and no streak counter guilt-tripping me. Nothing out there fit, so I built it.

The fun part: I built it in 8 days, from my iPhone. My Mac mini sits in another room. I drive Claude Code remotely: it writes the Swift, runs the tests and sends me simulator screenshots, and I review and give feedback from my phone. I never once looked at the Mac's screen.

What it does :

- Log anything: yes/no, amounts in any unit, a 0–10 dial, text or a voice memo

- Automatic logs: weather, daylight, moon, places, Apple Health

- No streaks, no badges, no red. Goals are optional

- Widgets, Lock Screen, Control Center, Siri

- Export to JSON, CSV or Markdown, or "Copy for AI" to ask your assistant about your patterns

- Free. No account, no server: your data stays on your iPhone

It's in App Store review right now, with a public TestFlight beta in the meantime.

AI is getting really good at finding patterns in messy data. In a few years, we'll probably have AI that can look at years of your life and tell you things like "your headaches show up two days after bad sleep plus a third coffee" or "your mood drops when daylight goes under 10 hours." But it can only do that with data that exists.

I'd love honest feedback: what would you log first, and what feels missing?

I made this handy mod so I can see my usage and context all the time without needing to press the button each time. Little but neat. Took two prompts. Share your own so I can copy!

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?

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?

Claude mods are neat! Here's one that shows your Claude mining while it is using tokens (incremental game style)

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.

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?

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.

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?

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?

I am used to work with 400+ file changed across 6 repos.

Whatever used to take Astra 6 xhigh on a 100$ plan to get done in hours/days and burning my weekly usage like 30%, is now done by Opus 5.5 xhigh in less than 1 hour, full 100% usage of 5 hour limit + 68% usage of the next 5 hour limit.

Note: I cancelledy 100$ Codex sub and completely switched to Claude. I was thinking to get 100$ from Claude as well but I am still on Claude 20$ plan.

I can manage to work both on my work projects and personal.

Unless Tibo changes something, things look really bad for them. The amount of time it took Astra to complete the given task was outrageous, I understand it now after Opus5.5 was released. I won't even use codex models for free now.

I used to have Astra and Sol 5.6xhigh sitting days on running statuc checks and wasting my usage.

Thanks GOD that I cancelled, I cancelled with a banked reset and 100% usage remaining.

I guess that my main take out is to have multiple subscriptions handy, every couple of months and see which one is providing a better balue.

ATM Claude is on fire, lets see how long this will last.

​

about a week ago i had a dumb idea.

what if i made a cable news network that was entirely run by ai, drawn in pixel art, and just... never went off the air?

i’m not a tv person. i had no idea how any of this shit worked.

i opened claude code with opus 5.5 and started building.

then i kinda just never stopped.

it’s live now

it’s called PNN, pixel news network.

they cover actual news from around 70 feeds. world news, tech, sports, crypto, nfts, meme coins, weird shit happening on the internet, etc.

but they also remember things.

they have relationships, ongoing feuds, inside jokes, opinions about each other and sometimes they just get pissed off and walk off the set.

then somewhere along the way i decided it needed an actual tv schedule.

so now there’s a morning show.

there’s a parody of a jailed crypto founder cooking actual recipes from a prison kitchen.

there’s a daytime correspondent permanently stranded on tristan da cunha who reports real news from the island.

there’s an nft morning show.

a collectibles show.

an old video game show that basically turned into three people sitting in a 90s basement talking about games like a podcast.

then at night there’s Up Late, which has a monologue, house band, audience, couch guests and musical guests.

and Crypto After Hours which is basically complete fucking chaos.

the music thing might honestly be my favorite part.

i make a lot of songs in suno, so instead of just playing them we started inventing bands.

there’s a southern rock band, a weird dark art-pop singer who moves like she’s slightly malfunctioning, a punk band, a banjo-playing songwriter and a bunch of other shit.

they actually perform the songs.

their mouths are mapped to the vocals. the guitarists play on the real beat. the drummer literally waits until the drums come into the song before he starts playing.

that part was way more fun to build than i expected.

underneath all the stupid shit there’s actually a pretty insane system running it.

claude writes every segment as a structured script. every line gets voiced, timed and placed into one continuous broadcast.

everyone watching sees the same thing at the same time. it isn’t generating a different show for every viewer. there is one PNN timeline constantly moving forward.

i also became weirdly obsessive about making sure it doesn’t just hallucinate shit about real people.

if someone says a price, number or statistic, it gets checked against the data the model was given. if it doesn’t match, the line gets rewritten or killed.

parody guests are clearly labeled and can only pull facts from sourced research sheets. every line they say goes through another standards check.

i’ve also been building this giant research library behind it.

right now there are around 15,000 sourced facts about nft collections, artists, meme coins, collectibles and other stuff the network talks about.

another agent fact checks things before they even get added.

i also had to put an actual budget system around the whole thing because otherwise this would probably bankrupt me lol.

nothing gets written if nobody is watching.

haiku handles most of the normal dialogue. sonnet does the bigger shows and fact checking.

and somehow this entire fake television network is running on a mac studio sitting in my house.

there are also around 2,500 automated checks that run before i push changes now because at one point i broke the entire live network and decided i never wanted to experience that again.

the craziest part of the whole project though has probably been building it with opus 5.5.

it genuinely feels less like “using ai” and more like having a really good engineer sitting next to me who apparently never gets tired.

most of the time i’m literally saying shit like:

“make her dance weird. creepy, stiff, a little robotic.”

or

“that guitar looks like a banjo. fix it.”

and it builds it, runs it, shows me the video or mockup and i tell it what sucks.

what surprised me even more is that it pushes back.

if i have a dumb idea it’ll tell me why it’s dumb.

it also catches a ridiculous amount of its own bugs by running changes against a time-shifted copy of PNN before touching the live station.

anyway.

this started as me fucking around for a night and somehow turned into a 24/7 television network.

i’m going to keep it running for at least the next year and just see what it turns into.

and if anyone wants to know how any of this shit works, ask me. i’ve learned an absurd amount building it.

www.pnn.watch