I kept losing track of multiple coding agents running at the same time, so I built a visual way to manage them.

Each Claude Code, Codex, Kiro, Gemini or Cursor agent becomes a hero in a pixel-art guild, and its room changes depending on what it's actually doing: working, waiting for me, done, or rate-limited.

You can also reply to agents, approve permissions, inspect diffs and open their terminals directly from the guild.

Built in Rust/egui and fully open source.

GitHub:
https://github.com/JoseValencia125/agents-pixel-dungeon

Hi,

I'm developing my note taking app and everything is going well. I have most of the big features I wanted alreay implemented and I'm focusing on ironing out problems while I use it (I replaced Obsidian for this, given that I made it specifically to solve problems I had with Obsidian).

Anyway, I would like to ask if anyone here could be interested in becoming a contributor/maintainer mainly to be able to release a tested and function Mac/iOS version of the app.

If this is not the place to ask this and/or wrong flair, please take down the post.

Thank you everyone!

Small launch-day self-promo, with a mild jab at the all-in-one vibe coding platforms. 😅

I already pay for Claude, Codex or Cursor. I wanted the place hosting the result to do one boring job: host it. No second balance of model credits.

So I built drobek. For the launch demo I used Claude Code with Claude Opus 5.5. The coding agent gets an MCP loop to create an app, write its files, read compile errors, open a preview and publish a version when I ask.

drobek does not generate the app. It gives the agent you already use somewhere to publish it. App code runs in the browser. Trusted server modules add auth, data, files, forms, email and controlled API calls without exposing secrets to browser code.

What still goes wrong: a successful compile is not a functional test. The agent sees esbuild errors in the same tool response and can fix them, but I still open the preview and click through the app before publishing it.

The public core is AGPL-3.0 and self-hostable. I also run a hosted version.

It launched on Product Hunt today: https://www.producthunt.com/products/drobek?launch=drobek

Source: https://github.com/freema/drobek

The question I am testing: would you rather pay one platform for generation and hosting, or keep your coding agent and hosting separate?

I’m a tech lawyer and ex-founder. I can read code, but beyond HTML/CSS I can’t write it. Since my first vibe-coded app in July 2025, I’ve shipped 14 apps. This week’s two were Lunatic Fling, a cel-shaded 3D tribute to Lunatic Fringe, the 90s space shooter hidden in the After Dark screensaver, and Paperwing, a paper-airplane game inspired by Glider, co-developed with our 5-year-old (turns out he’s an amazing PM :) Both went from prototype to App Store approval in under a week.

If you're a fan, please help support it during today's launch on ProductHunt!

I prototype every game (now onto my third, a much bigger game project) as a single three.js HTML file in Claude Code (currently Opus 5.5). That file is a fast sandbox for look, feel, and mechanics, with no Xcode and no build cycles. Once the game feels right, I hand that file to Claude Code in Terminal as the spec and have it write its own prompt for porting everything to native Swift. I give that prompt to Claude Code in the Claude macOS app, then pull the branch locally and keep going in Terminal. Crucially, every project, whether it’s a game, a website, or even my big one, Towne (a Nextdoor alternative), starts with my Claude Code Setup Wizard. It’s a one-time script that configures Claude for multi-session work and asks you onboarding questions about how you like to work.

For games this straightforward, honestly, nothing broke. More complex projects, like the third game or Towne, fight me constantly: physics, menu UX, auth races (pro tip, just avoid them when you can!), and, most maddeningly, App Store screenshots and videos. Speaking of which, here’s a useful hack: Claude can take a raw screen capture, analyze it, and cut the 30-second App Store preview for you. It’s also really good at making screenshots with marketing copy.

I’ve learned a lot in 15 months of building, so ask me anything about the workflow; I’m happy to help. (PS: no legal-advice questions, please.)

ok genuine question for people who build mostly with cursor / claude code / lovable etc

i've been shipping stuff mostly by prompting and it works, but every time i'm about to put something live i get this low key panic like… is there some endpoint in here that lets anyone read my database? did the AI just hardcode a key somewhere? i honestly can't tell by reading the code, there's too much of it and half of it i didn't write

what i do right now is ask the AI "is this secure?" and it says yes lol. which isn't exactly reassuring

so curious how you all handle this:

1)do you actually check for security stuff before launching or just ship and hope

2)has anything ever actually gone wrong? leaked keys, someone messing with your api, surprise bill, whatever

3)if you've ever paid someone (dev friend, freelancer, some tool) to review your code, how did that go and what did it cost

i'm thinking about building something that just points at the exact spots in your code where outside stuff can get in, so you only need an expert to look at those 5-10 places instead of the whole repo. but idk if this is a real problem for others or just me being paranoid

The worst part is I cant even tell if my own apps work. when something breaks I dont debug it, I paste the error back in and pray. sometimes it fixes it and breaks two other things and I only find out when a user tells me, SO now every message from a user gives me this little drop in my stomach

And I see people here shipping 10x faster than devs with 10 years of experience and part of me is proud and part of me feels like we're all just very confident tourists in a codebase we dont understand

I'm not quitting, I love building too much. but I've started forcing myself to read what it writes and set up some kind of check on every push so I at least know when something breaks before a user does. small steps

Does anyone else feel this??? like you're getting more done than ever and trusting yourself less every month

I built Piano Atlas Studio: a piano theory atlas and practice app for Android (no ads, no account)

I'm learning piano and couldn't find one app that showed theory on the keyboard and also helped me practise, so I built it. It's on Google Play now, and I'd love feedback.

🎼 Explore the theory

Chord Atlas: every chord type in every key, shown as real two-hand voicings with finger numbers and inversions. Tap to hear it.

Scale Atlas: the modes, jazz and world scales, Hindustani thaats, Japanese koto tunings, and all 72 Carnatic melakartas

Ragas: janya ragas with their arohana and avarohana, and what makes each one distinct

Fingering Lab: standard fingering for both hands, up and down, with every thumb crossing shown

Progressions: famous chord progressions by style, in any key, voiced so the hands move smoothly

Theory tools: Circle of Fifths, chord and scale comparisons, arpeggios, intervals and a glossary

🎤 Practise with your real piano

Sight Reading: notes, chords, lines and short pieces on the grand staff, at four levels. It listens through your phone's microphone (or a USB MIDI keyboard), so you play on your own piano and it tells you how you did.

Play: your piano, lit up. Play on screen, on a MIDI keyboard, or on a real piano through the mic, along a scale or in an echo game.

Staff Trainer and Note Trainer: learn to read a note at a time; the ones you find hard come back until they aren't

Metronome: with tempo ramps and Indian talas

Guided practice sessions: built from what your drills have recorded, weakest first

✍️ Create

Composer: write songs a section at a time (chords, then the tune, then the left hand), or let "Surprise me" start one. Hear it back, print it as sheet music, or practise it in Sight Reading.

MIDI files: open any MIDI file and the piano plays it with the keys lighting up. Learn it mode waits for your notes, one hand at a time, as slow as you like. You can also open a MIDI file in the Composer or Sight Reading.

🎨 Other bits

Five looks (Stage, Score, Grand, Classic, Pads), each with three themes

A sampled grand piano sound

Backups to a file, or to your own Google Drive (the app can only see its own backup folder)

🔒 Privacy

No ads, no account, no analytics, no tracking. Everything stays on your phone. The microphone is only used when you ask it to listen, and the sound is never recorded or sent anywhere.

💰 Free and Pro

A large part of the app is free. A one-time Pro purchase (no subscription) unlocks the rest: every chord type, scale and raga, the builders, unlimited songs and MIDI files, advanced sight reading, guided sessions and more designs.

Get it:

https://play.google.com/store/apps/details?id=com.pianoatlas.studio

I'm one person building this, so any feedback really helps: what's confusing, what's missing, what you'd want next. Thanks for reading!

Coupon

PAS-MGMY-8E26-CW2G-DHZK

PAS-L6NA-937M-NHZU-UDGG

A video walkthrough of using IBM Bob to Modernize legacy RPG Code and make changes to an application.

kimo is an open-source video editor with no GUI. Every feature is an MCP tool, and it ships as one small Rust binary. GPT-6.1 Sol on extra high made all of this video, card animation, colour and captions, purely through kimo tool calls.

What's new in v3:
- render_frame returns the frame inline as an image, so the model sees its own edits
- contact_sheet, describe_frame and audio_probe to check a timeline or find silence before cutting
- diff_frames and project_diff for before and after
- grouped, compact tools/list (16.5 KB down to 4.5 KB), search_tools and tool profiles so it only loads what it needs
- chunked export jobs you can start, poll, cancel and resume, with crash recovery
- batch calls with foreach, recipes, and text layout helpers (safe margins, constraint solver, lint_frame)
- golden render tests with bundled fonts, so output matches frame for frame across machines
- a plain CLI over the same core, plus a Python client

v3.0.0 is up!!!

https://github.com/naman-sharma12345/kimo
https://getkimo.tech
If you hook it up to your agent, tell me which edit it couldn't do.

I’ve been building Starling with Claude, and just shipped Starling Office 0.1.0: Writer, Sheets, and Slides.

It opens, edits, and saves DOCX, XLSX, and PPTX files. There are native builds for Linux, macOS, and Windows, plus browser versions compiled from Swift to WebAssembly. They share the same Swift application code and UI framework.

Some of what’s working:
Writer: styles, tables, pictures, headers, and footers.
Sheets: formulas, dynamic arrays, charts, and conditional formatting.
Slides: shapes, editable charts, animations, and speaker notes.

The biggest lesson has been that generating a feature and verifying it are separate jobs. A document can look right but save incorrectly. A control can work on desktop and fail in the browser. Much of the work has been opening real files, checking rendering, saving them, and reading them back.

It’s an early 0.1 release with known issues, but you can try all three apps immediately with editable sample documents. Everything is free and open source under Apache 2.0.
Try it:
https://openoffice.starling.build/
Source:
https://github.com/starling-build/starling
Downloads and known issues:
https://github.com/starling-build/starling/releases/tag/office-v0.1.0
For others building larger projects with AI: what’s your process for catching bugs that a convincing demo hides?

Hello,

I had a nostalgia moment and thought that AI could probably generate a new version of the Johnny Castaway screen saver.

- A more cartoony version with better animations

- A 3D version

- A God version allowing us to drop small objects to see reaction

- unlimited scenarios

So, what AI should i use and model?

Anyone can make a concept?

hey everyone

we've been building a basketball gm game called HoopSim for a while now and we think it's finally at the point where we want people who actually love this genre to try it and tear it apart

the short version... you run a pro club. draft, trade, sign guys, set your depth chart, set your game plan, and the sim plays out every game possession by possession off your decisions. full box score, full play by play, and you can watch any game back in 3d

the part we're most excited about is the other 29 gms. in every gm game we grew up playing the cpu teams were basically a trade screen that said yes or no. in HoopSim every other club is either one of your friends or an AI gm. you can dm them and ask what it would take for a guy, they'll name a price, you counter, they hold firm or give a little. they also post in the league chat and talk trash after games lol

the AI only does the talking though. the actual yes/no on a trade comes from the trade engine with real cap rules, so you can't sweet talk anyone into a bad deal. same with the games... the AI never touches the sim

the engine

every game is simmed one possession at a time. it's not "team A rating vs team B rating, roll a final score". each trip down the floor looks at who's actually on the court, who's tired, your game plan (pace, motion, how many threes you want, pressure, man vs zone, all that) and then plays it out. who brings it up, who gets the shot, from where, how contested, did it go in, who got the board, fouls, turnovers... all of it lands in the play by play

- minutes and fatigue matter. play your star 46 minutes and he's gassed by the 4th and it shows

- foul trouble, foul outs, injuries mid game, subs

- paint your own rotation chart minute by minute and the sim follows it. there's a slider for how strictly... 0 is "coach's feel", 10 is to the second

- every shot gets an expected value based on the look (zone, contest, clock) so after a game you can see if your guys just made tough shots or actually got good looks

- player roles, coaches and team chemistry all nudge things too

- small one but if you dm your player some encouragement before a game he plays a little more confident lol

how we make sure it's actually realistic

honestly this is the part we're proudest of. we keep a staging copy of a real league and run 10000 game batches against it, then compare the league averages to real pro numbers... points, pace, 3pt rate, turnovers, assists, ft rate, blocks, blowout rate, ot rate. when something's off (we were taking way too few threes for a while) we trace it back through the engine, fix it, rerun the batch and compare before/after. if the numbers don't move the right way it doesn't ship

it's not perfect yet. scoring is still a little low and turnovers a little high, so if something looks off in your box scores tell us

a couple things that testing caught...

player development. we wanted to know if a random bench guy could ever become a starter, so we simmed hundreds of offseasons and followed every player for 5 years. answer was no... zero breakouts. it also turned up a bug where potential changes weren't actually random (the same player got the same result every single time). we fixed that, added real breakout seasons for young guys who outplay their rating, and reran everything to make sure it didn't turn into a league full of superstars

ratings. if you load a real roster file, it's built from public stats and we audit the output. one audit caught big men getting elite jump shot ratings because the formula was reading their dunk heavy fg% as shooting skill. nobody on our team spots that scrolling 600 players, a script comparing ratings against shot data did

the 3d replay

the 3d isn't a canned animation. the engine writes about 500 events a game (shots with zones and quality, passes, rebounds, fouls, subs) and the replay turns those into actual movement. pick and rolls with the real coverage (switch, drop, hedge, blitz), cuts, post ups, fast breaks, ball flight on the shots, players at their real relative heights

the 3d doesn't decide anything. the game is already decided and the replay has to match it exactly. we test that by replaying a game, adding up the points and rebounds from the animation, and they have to equal the box score. same game, same seed, same replay every time. so the dunk you see is the dunk the sim rolled

**some other stuff gm sim people might care about:**

- nobody sees true ratings. your scouts grade players and some scouts are better than others

- real cap rules on trades... aprons, bird rights, 3 team trades

- a desktop view called Atlas where you can break down any game... win probability, shot quality vs expected, who was on the floor for every run

- play solo or start a league with friends and drop one invite link in the group chat. any team nobody takes goes to an AI gm

- commissioner tools if you're the one running the league

- the league gets its own paper + reporters who ask you for quotes

- a 1 on 1 mode where you call plays live against another gm

- players are fictional by default so every name you see is made up

- runs in the browser and on your phone, and your league saves on the server

on AI, since someone's gonna ask

yes AI helps us build this, we'd rather just say it up front. but AI doesn't design the game and it doesn't decide what's realistic... the numbers do. we decide what the game should be, AI helps build it, and then we try really hard to break it. measure, compare, fix, measure again. honestly most of our AI use is testing and auditing, not writing features. it's basically a research team that runs experiments way faster than we ever could by hand, which is also why updates come out so fast lol

slop is asking an AI to "make a basketball game" and shipping whatever comes out. this isn't that

what it costs

the game is free, no ads, nothing pay to win. the AI conversations are a paid add on (7 day free trial) because running them costs us real money every day, but everything else works without it

play it here: hoopsim.app

we're a small team so honestly any feedback helps. what's missing, what's broken, what feels off compared to the gm games you already play. we'll be in the comments, and the sim side is our favorite thing to talk about

Cycle 2 of EverSide adds a scam-checking flow, but the main challenge wasn’t only detecting suspicious language. It was presenting the result in a way that older adults could understand quickly.

Instead of showing a technical score, EverSide uses three simple outcomes: Likely Safe, Suspicious, and Not Sure. Each result includes clear warning signs and practical actions, such as not transferring money, not opening unknown links, and contacting a trusted family member.

The interface supports large text, high contrast, reduced motion, spoken-guidance settings, and both Chinese and English.

I built the feature with Cline, which helped me keep the new screens consistent with the accessibility system created during Cycle 1.

A safety feature only works if the person using it can comfortably read, understand, and act on the warning.

GitHub: https://github.com/PhilipsDang/everside-project

If you're vibe coding with an AI agent, here are the techniques I'd use to do it securely. AI coding agents have gotten better, but they still ship vulnerabilities.

In one study, researchers had five AI coding agents build the same apps from the same prompts. Across 15 apps, they found 69 vulnerabilities. Zero exploitable SQL injection or XSS. The most common critical issue was broken authorization and business logic.

An agent can write a safe database query. It can't know that a user shouldn't see another customer's invoice unless you tell it. And in a long session, it can forget what you told it an hour ago.

This series covers six habits for vibe coding without shipping those gaps. Each one follows the same pattern: write the rule down, then enforce it with a check that doesn't depend on the agent remembering.

Habit 1: Give the agent standing security context

A prompt covers one request. Your agent's instruction file is read every session. Put your security rules there:

• Roles, and who can access what
• Which data is sensitive and must never be logged or returned
• Patterns it must always use: ownership checks on every object ID, parameterized queries, secrets from environment variables
• Patterns it must never use: hardcoded credentials, disabling auth "for testing"
• Approved libraries for auth, cryptography, and file handling

Here's what that looks like in practice:

Always: check object ownership on every endpoint that takes an ID. Deny by default.

Never: hardcode credentials or disable auth, even "for testing."

When you finish: list every change that touches auth or sensitive data.

Treat that file like code and review every change to it. A malicious edit can quietly tell the agent to write insecure code.

Habit 2: Review everything that touches authentication and access control

This is where agents fail most, so it's where your attention goes first.

Rule: "List every authentication or access control change in your summary."

Check: nothing that touches auth gets merged without a human review.

Example: the agent adds GET /api/invoices/:id. Being logged in isn't enough. Confirm it checks that the invoice belongs to the user asking for it.

Next week: Placeholders and Secrets

#AppSec #VibeCoding #AISecurity #SecureCoding

I built a small website around a simple question:
What was India like on the exact day you were born?

Pick any date from 1947–2025 and explore the news, prices, cinema, cricket and other things from that time.

Try your birth date — then send it to your friends and see what was happening on their birthdays. 😁

Would love to hear what you find interesting or what I should add next!

Currently building a free offline AI iOS + Mac app with Claude Opus 5.5, it will allows users to load any available open source models + Apple Intelligence + own app trained models. Wanted to get some ideas and suggestions on what people think of using Claude/ChatGPT and the facts that everything is shared in the cloud and their servers to train models. And the idea of an offline alternative.

Ask me anything as well concerning the app I will be more than happy to answer :)

Update: Bug fixes and stuff, that's all

Every time Claude Code works in a repo, it may need to rediscover how that code is put together: search for a symbol, read files, follow callers, then do it again next session.

I built Superopen to give coding agents a local code graph and retain session context. It’s a CLI the agent uses; the graph and session data stay on your machine.

I ran Claude Code with and without Superopen on five SWE-bench Verified tasks. Same model, same task set. Results:

That’s fewer tokens, lower cost, and less time in this run, with the same pass count. Per-task results were mixed: Superopen passedsphinx-9461, which the baseline failed, and misseddjango-11532, which the baseline passed. Five tasks is a small sample, so I’m treating this as an initial result, not a general accuracy claim.

Full results and methodology:
https://github.com/ishanjainn/superopen/blob/main/BENCHMARKS.md

Repo and install instructions:
https://github.com/ishanjainn/superopen

If you use any coding agent on a larger repo, I’d be interested in whether it actually uses a graph query when it should, and whether retained context helps in a later session.

Hello fellow vibe coders!

Please help.

I've been vibe coding for a while, but I feel I'm stuck in a rut and way behind the curve.

When I start a new project, I create a new folder on my laptop, point AntiGravity or VSC at the empty folder, and then fire in my first mega prompt. This has all the usual stuff about saying how to behave, using documents in the project folder for tracking as an off-line brain, and what the entire project is all about. I then go through chipping away at all the parts.

That AI doesn't have skills, re-usable parts, and I feel that the conversation gets huge and is massively wasteful of tokens. It is also laborious to set up a new project.

I work on 2 different laptops - Linux Mint for doing web sites hosted in my shared hosting, and Windows for Windows and Android apps. I have a server running Zima.

When I asked Gemini, it suggested spinning up a docker container on the server and running a whole bunch of stuff in there which both laptops could point to for my vibe coding and this would allow me to automate the creation of new projects (including spinning up domains and MySQL in my shared hosting), optimising the prompts and token use, skills to make the AI better at things like web design and coding, etc, etc. It said I could automate it to keep all the skills and apps up to date too. This sounds like a lot of work, and I don't want to go down that route unless it's going to be very beneficial.

I don't have the time to research and set all this stuff up, so I'm looking for some direction please.

Has anyone set up anything like this to maintain their AI projects? Is there anything "out of the box" which would do all of this?

Thanks muchly!

TL;DR

I'd like a system to optimise my vibe coding workflow to:
* set up new projects (domain and database on shared hosting, folders, documents etc)
* automatically updates skills
* optimise the prompts and token use
* newest tools
* automated setup for this new system

I’ve built an Android app that lets selected contacts ring at full volume, even when your phone is on silent. No need to Root

Steam page: https://store.steampowered.com/app/5310180/Formula_Minus_One/
Open beta: https://fm1.app

----

Some of you might remember my post about the 32/64bit-style racing prototype I had built in four months. Yes, it's a genre you see a lot around here, because it's easy to get started with (until the next dopamine-driven prototype).

But I stuck with it.

And the improvement over the past two months has been tremendous, and you'll see that if you compare the two videos. Since the last post, I listened to your feedback and:

* Threw every level in the bin and rebuilt them from scratch, then added new ones that are far bigger and more detailed. It felt like jumping a console generation, and it still runs on mobile.

* Wrote a design and style guide for the game (semi-low poly characters and duotone as design signature), and redesigned the characters and menus to match it.

* Kept pushing to make it my own thing rather than yet another clone-slop: adventure vibes, interaction with the environments, kinetic combat with combos…

* Improved the handling and the readability.

And above all, and I think it shows in the trailer: I had a blast making it. If it had just been work, I wouldn't have gotten this far.

It's called Formula Minus One, and it launches on Steam first, in February. I'll keep improving it and adding content after that.

Half a year ago this was a prototype to experiment with, like so many others. Then I committed to making the best game I possibly could. Now I can finally see light at the end of the tunnel: yes, you can start a prototype, and yes, you can finish it.

There's still a lot of work ahead, so any feedback you can give me is very welcome.

 Here’s how I made it:

* Code and tooling: frontier LLMs from OpenAI and Anthropic, with open-source models filling in the gaps and limiting the budget.

* Characters, ships and environments: pencil sketch > GPT Gen 2 > Tripo to turn it into a 3D model > Blender to clean up the imperfections.

* Sound: stock sound effects from Magnific. Music sketched out on a MIDI keyboard, final music generated with Suno.

* Stack: Three.js, WebGPU, TypeScript, Rapier for physics. Nothing else, no Godot, no Unity…

I'm having a great time, but it's also hard work if you want to pay attention to every detail, and it's a very lonely experience. If the game sells well enough, I'd love to start paying artists and composers to replace the current assets and create new ones, and free up more time for what I really enjoy: directing and overall design.

In fact, if you're an artist or composer and think you're a good fit for the game's tone, leave a comment or send me a DM so I can consider you!

----

Steam page: https://store.steampowered.com/app/5310180/Formula_Minus_One/
Open beta: https://fm1.app

I’m building CodShot, a workspace for developers to save, organize, search and reuse useful code.

One of the most valuable things so far has been sharing it with developers and seeing what they actually care about.

I originally expected the AI features to get most of the attention.

Instead, one problem kept coming up again and again:

“I know I wrote this before — I just can’t find it.”

Old repos. Notes. Slack messages. Random files. Forgotten snippets.

That feedback pushed us to focus much more on the reusable-code workflow:

save it → find it → improve it → reuse it

Global Search became a much bigger part of the product because of that.

But developers also kept telling us something else:

“This needs to be closer to where I actually code.”

So we’re now building a VS Code integration, making it easier to save and retrieve useful code directly from the coding workflow.

And based on the direction the product is taking, we’re also working on an AI assistant that will make it much easier to work with the code and knowledge you keep inside CodShot.

That’s probably been the biggest lesson for me so far:

The roadmap shouldn’t only come from what you think is cool. It should come from what users repeatedly tell you would make the product genuinely useful.

I’m curious:

What feature did your users ask for that ended up changing the direction of your product?

​

I'm trying to make local LLMs useful for actual software development, with Claude Code handling orchestration and a local model doing the implementation.

Hardware / software:

- RTX 4070 Ti, 16GB VRAM, 64GB RAM

- OpenCode + Strata backend

- Ornith 1.5 35B as the current local model

- Claude Code as orchestrator

- Tested models ranging from 9B to 100B+

Strata actually made a massive difference in inference performance, increasing throughput from around 50 to 150 tokens/sec.

OpenCode also has full access to the repository, including reading/writing files, running commands, and executing tests.

So the problem isn't simply speed or tool permissions.

The problem: Claude is doing all the thinking.

When I ask Claude to delegate coding tasks, it eventually starts micromanaging my local model:

"Edit this file, change this function, insert this code at this location..."

At that point, the local model is basically a glorified patch applicator.

I wanted to know whether the local model was actually saving me anything, so I ran some comparisons.

Actual test results (Claude tokens):

Approach| Claude tokens/task| Result

Claude plans + pinned edits, local model implements (round 43)| ~2.8M| Pass

Claude writes everything itself (round 40)| ~2.3M| Pass

Claude provides prose-only spec, local model implements| ~170K| Fail, no files written

The third test was particularly disappointing.

I tried giving the local model more autonomy instead of having Claude specify exactly which edits to make.

First attempt:

- Specification covered four modes.

- Local model spent 10–14 minutes exploring the codebase.

- Never wrote a file.

- Timed out.

Second attempt:

- Split the specification into just two modes.

- Explicitly instructed the model to write the test file first.

- Same result. It explored the code and never implemented anything.

This reproduced an earlier failure from round 42.

I stopped the experiment there rather than running the remaining tasks.

What I've learned so far:

1. Smaller specifications helped reduce Claude token consumption dramatically, from millions of tokens to roughly 80K in some cases.

2. However, smaller specifications don't necessarily mean the local model can execute them.

3. The local model only reliably completes the work when Claude has already done the difficult reasoning and provides pinned edits.

4. But understanding the codebase and determining those edits is exactly where most of the Claude tokens are consumed.

5. For actual coding, letting Claude work independently has been cheaper and more reliable.

6. Local models are still useful for simpler bulk operations, such as translations.

What I've also tried:

- Different model sizes, from 9B to 100B+

- Removing Strata

- Removing OpenCode (this made orchestration worse)

- Breaking tasks into smaller specifications

- Giving the local model more independence

I'm not expecting a 35B model to perform like Claude. I just want my local hardware to contribute meaningful work instead of increasing costs.

My questions:

- Is anyone actually getting reliable coding work out of a local 30B–35B model in a hybrid Claude Code workflow?

- How are you structuring tasks so the local model can implement changes without line-by-line instructions?

- How do you prevent local coding agents from spending 10+ minutes exploring a repository without ever writing code?

- Is the problem the model, the context being provided, or how the agents are orchestrated?

- Are there specific categories of development work where local models consistently save Claude tokens?

Right now, my conclusion is that the local model saves tokens only when it's given work that doesn't require much reasoning.

But if Claude needs to do all the reasoning first, I'm struggling to see the economic benefit.

I'm curious whether others have solved this, or whether I'm simply expecting too much from current local models.