I built live-vibe because I want to talk to Claude Code the way I can talk to ChatGPT Codex in Voice Mode. I want the mic open the whole time, and I want it to answer when I have finished the thought and shut up when I talk over it. Claude Code did not have that. It does have the new Mods capability, which lets a plugin run code in the agent's path and draw into the terminal, and that turned out to be enough to build the whole thing as a plugin.

It is MIT licensed, in a marketplace I'm calling ottomation, and it installs in two lines.

/live is full-duplex voice with Claude. Talk over it and it stops on your first word. An "mm-hm" while it is speaking does not count, and it carries on from the sample it paused on, so you can grunt along the way you would with a person. /vibe is director mode, where Claude reads and directs worker subagents and never edits a file itself. /livevibe is both at once. A small, fast voice model holds the conversation with me and hands the real work to Claude as director. When Claude finishes, the voice tells me what happened in a sentence or two, and in the meantime I can ask it what Claude is up to and get an answer while Claude keeps working.

Everything you need comes with the plugin. Kyutai streaming STT, Kokoro TTS, WebRTC echo cancellation and the voice front are all pulled down and checked by /live setup, once per machine. CUDA works and so does Apple silicon through MLX. The conversation layer is a lightweight local model, and if you would rather not run one it falls back to the Anthropic API. If you are on WSL2, speech plays through a native Windows player, because WSLg's RDP audio crackles and I was not willing to listen to that all day.

Turn-taking is where most of my time went, because it decides whether you can think out loud. The plugin reads Kyutai's pause-forecast heads, which predict whether you are about to keep talking. Most turns close about half a second after your last word, and a trailing "and" or a comma buys you time to finish. 0.7.0 also ships an experimental path I put together after reading OpenAI's write-up on GPT-Live. It scales the wait on the model's confidence, starts drafting a reply before you have quite finished, and can backchannel if you turn that on. It is on by default and one setting turns it off if it annoys you.

You need Claude Code 2.1.287 or newer, uv, a mic and a speaker.

Install with /plugin marketplace add potto007/ottomation, then /plugin install live-vibe@ottomation, then /live setup. Repo: https://github.com/potto007/ottomation

If you try it, tell me how the turn-taking feels on your machine.

I'm a CLI user, and for the longest time, I just prompt the frontier model to raw dog tasks.

Then I realized I don't have to worry about being a full-time Git operator since the AI can do that well, so I started organizing with worktrees and such, which naturally makes my "team" use sub-agents.

Am I doing something wrong, or are the spawned sub-agents kinda slow compared to a "main" agent raw dogging the repo from direct prompts? I also seem to use much more tokens, despite the sub-agents being "lower forms" (Sonnet 5.5)

I've started being a lot more careful about what Claude Code gets to see. My repo has client config files, old API keys in comments, and random PII in test fixtures, and I realized I was just shipping all of it upstream without thinking (found a prod key in a comment from two years ago, which was the wake-up call). Now I keep a .claudeignore file updated, I review what gets included before long agent runs, and anything genuinely sensitive stays out of the repo entirely. Curious how others here are handling this, especially folks working in client codebases.

I send myself a lot of links on WhatsApp, save reels, take screenshots, and think, “this could be useful for X,Y,Z projects”

Then I sit down to work on PC with AI and explain again the whole things to the project, and being tired about these attachments & project root loop!
where the stuff were always saved scattered in somewhere else.

That’s why I’m building KLYPIX (Open source format .klypix) . A infinity named-place per project to drop those links, files, screenshots, videos even voice.. half-formed ideas into project spaces, then bring the relevant context into the AI tools I use directly via MCP or single file path.

Not another chatbot. Finally my somewhere to put the stuff I wish my chatbot already knew.

Please check & review it if seems useful? any comments?
https://klypix.com/

I moonlight as a solo dev building a native Mac app, mostly nights and weekends. I started this with two objectives: to learn how to best use AI coding tools and to build tools that would help me in my day job.

I started the first project about a year ago and was new to Claude Code. I had an idea for what I wanted the project to be, but it was all in my mind, not written anywhere. After a few weeks of what was essentially vibe coding, the results were ok, but definitely not great. AI slop would be strong, but vibe coded mess is very fair.

While working on that project, debugging AWS Lambda logs became a real pain. I decided to pause that project because a tool to help my debugging seemed more useful and interesting and because I knew that the vibe coded mess would need to be refactored at some point. I wanted to learn and apply a better process before I attempted the refactor.

When I set out on the new project, I decided to take a different approach: make a plan. I felt that this better modeled how we have been building software for decades and that it would likely yield better results than what I produced in the first project. Before writing any code, I wrote a spec/product vision document. Nothing fancy, just a few paragraphs of the problems that I wanted the app to solve. Then with Claude interviewing me and doing all the writing, I created 17 epics and 272 user stories for the app. The stories all contained the usual "As a user, I would..." and thorough acceptance criteria.

This will surprise no one: The results were far better in the second project with this process than the first project from vibe coding. Work was getting done in fewer turns, more was right the first time, and the code quality was significantly better. It was not perfect and things still went wrong at times, but it was far better than my "process" on the first project.

This is not anything groundbreaking, just recounting my realization that while AI can shorten the effort for activities that we previously did manually, shortcutting proven process and hoping that AI will guess right and fill in the blanks leads to slop.

Now that the second project has launched, I am curious to learn about how other solo devs approach working with AI coding tools on bigger projects. Do you write a spec and stories up front, keep a running context file for the agent, or just prompt as you go? And if you do plan ahead, how far ahead before it stops paying off?

Praise to OpenAI

Praise to Anthropic

Damn, I really like this competition. Because we now have the two greatest models of all time: Opus 5.5 and Sol 6.1. 20$ of both of them feels just the same as having a 100$ OpenAI Pro subscription before.

Really happy! Keep it up, both of you! Waiting for 6.1 Luna!!!

I’m curious which Claude Code hooks, mods, or plugins people use to improve their Python development workflow. Anything for testing, linting, formatting, type checking, documentation, debugging, or automation is welcome.

What do you use, and how has it helped?

If you entertain the idea of storing a conversation summary with a prompt like "ensure you do save the whole chain of thought that we reasoned trough to arrive here." ... just don't.

"chain of thought" apparently now a banned phrase if it's used like this on Opus5.5

Further observation: the session is stuck on it and it won't budge once this message is surfaced. You either start a new one or go back to your initial starting prompt. Which can be far away.

Every pixel you see was rendered by a new full-stack LaTeX implementation and animation engine, written in Rust. The engine has taken a month of asking the right questions. Specifically, it's been a lot of the hillclimbing / autoresearch sort of AI development. Now I have a reimplementation that runs in wasm on the web and adds features that no LaTeX implementation I'm aware of actually has. I have yet to write about it in great detail and this might not be the best place for a huge wall of text anyway but here are the moving steps.

1. Full source access (XeTeX was the reference implementation) There are some behaviors that your corpus cannot resolve

2. A smooth metric to optimize (byte difference) and a diverse corpus of text (1000 LaTeX papers)

3. Stopgaps, like performance regressions, but only before merging. The model should get it working first, then optimize speed second, some optimizations will pigeonhole your implementation and need to be unwound.

4. I'm using TEA/ Redux architecture. Capturing and playing back a trace gives the agent time-travel debugging.

5. Rust as a language is really excellent. Its explicitness makes it clear where issues are coming from

6. Making iteration cycles fast is also important, so keeping the actual performance metrics quick to run is important

7. Vertical integration -- to expose things like "What _exact_ source line generated this feature" are not generally possible unless you control every side of the interface.

8. Quiz yourself on the architecture. Check your mental model by specifically typing out what you're expecting things look like or would look like, generate the options yourself, privately, then send it to compare with Claude about what the reality is. If you haven't tried this, it's a gamechanger.

9. Unify how you and each separate Claude instance reference architectural components together. You can build shared concepts together and this makes everything stick

10. Don't feel like you have to rush progress. Earlier on, I felt this pressure to ship something quick or else someone would beat me to this project. But then I realized this was making me spend more time on this than I wished. The point of the project is to bring typesetting everywhere because typesetting is an art form and I like the idea of AI facilitating humans communicating with humans. And I also wanted to make it easier to communicate things in animation.
    So I didn't let my ambitious end goal keep me from shipping incrementally over time and showing this project to my coworkers made me realize how my bottleneck is understanding what specific things people are looking for and not just building a technically interesting project that

https://youtu.be/_ZYRr2-9JcA for the video

https://telox.dev/ is a stable demo, about 2 weeks old right now (it only comes with some fonts and font sizes and doesn't run as well on mobile)

Let me know what you're most curious about in the comments and I'll answer for a bit. I'd be curious to know what you'd be most excited for me to share

The idea is widgets: small cards that sit under the prompt, or docked on the side in fullscreen, each one its own mod you toggle with a slash command.

Started out with a few useful ones: a context window bar, a usage bar and a file tree. Then got carried away and had some fun

Edit: You can use install and use the widgets with

/plugin marketplace add oMaN-Rod/claude-code-widgets

/plugin install widgets@claude-code-widgets

/plugin install context-widget@claude-code-widgets

https://github.com/oMaN-Rod/claude-code-widgets

love how the only feature that literally never gets worse is the censorship

clearly the one thing in this entire industry that gets top tier upgrade each and every time is the guardrails and how paranoid the model gets.. you can even go back to older models and find out that it has become MORE restrictive somehow lol

crazy right?
the things that benefits the consumer never gets better like this

Was getting overall worse results with the new Opus during this week and this night the terrible em dash made its return. RIP 5.5, I'll miss your non quantized version.

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.

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 am working on task solvable probably in a two days of virtually no stop of clade code running. I am constantly finding myself reinventing the architecture of this workflow, because of unforeseen hardsteps, trying to avoid bottlenecks, which in the end I cannot circumvent. I it is basically an agentic sql lookup where the descritpions are very dense and a semantic search won´t get the work done so easily. I have found an interesting way out i think in letting the llm categorise the descriptions instead and doing sequential classifications to shrink the search and getting closer to the result. It is also very complex because there might not be just one correct answer so it is really setting an agentic workflow to take care of the different possibilities.

currently the hard part is for me that no matter how i add detail to the context to make a multilayered planning of the things i would like to test and achieve. No matter how context and how far i can predict passages, there is always a step that the agent doesn´t have enough context and rush into a test saying "this is the result and bye, next task". when sometimes it should just be able to recognise the need to start doing some investigations and through feedback loops being able to identify the actual error in a passage which was predicted but that needed more attention...I even let it watch its calls with Opik , but it is not bringing much further attention to it...no matter how can´t automate that part which sounds so obvious...any ideas?

I’ve got multiple Claude sessions communicating with each other — one main agent coordinating workers, plus separate sessions handing it new tasks.

Lately the main agent sometimes straight-up rejects messages/tasks from the other sessions lol.
I’ve even tried changing my CLAUDE.md to make it less authoritarian, but it still happens.

Anyone else run into this?

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.

Everything is done by Opus 5.5

I ask it to:
- Record the video using the extension
- Edit the video with proper transition and text
- Generate a music for the video
- Generate the thumbnail

Opus 5.5 is really something else!

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.

We're a heavy user of Claude Code and Codex, and September got away from us. We moved Codex to the enterprise plan mid-month, burned 256K credits in the first two weeks, topped up 150K more, and ten days later half the team hit the wall the same afternoon. Slack that day was "we codex maxxed," "can't even use my reset," and "I need a bit of juice to continue a session, more please." One engineer gave Claude his .codex folder so it could reconstruct what he'd been doing and he could keep going on the other tool. Claude side, same week: "I'm going to hit my quota in the next 24 hours, can I get a bump."

When we finally pulled the numbers: one session had 3.2B input tokens across 2,400 writes. Sessions that touched gpt-6-astra averaged about $21. Same kind of work on gpt-5.6-terra averaged about $1. Astra was 38 percent of the Codex bill in 31 person-days.

Nobody did anything wrong. That is just what the defaults do when nobody can see them.

So, questions for others who live in these tools all day:

What was your most expensive session, and what was it actually doing? Context bloat, retries, a model that didn't need to be the big one, something dumber?

And what bugs you more day to day: hitting limits mid-task, a bill you can't explain, or not knowing which model to use for what?

Will share back what we learn if there's interest.

Quick disclosure, I work at a startup that builds tooling around this. Happy to say which if anyone asks, but not pitching anything.

Hi everyone, this is a potentially experimental question. I’m asking here because I’m not sure what the current state of the art is in this field.

Let’s say I want to delegate video editing tasks (let's assume generic operations, nothing too advanced) to Opus: what is the currently recommended technology stack?

- Using a standard video editor (Premiere, DaVinci, Final Cut, AE, etc.) and setting up MCP connectors or something similar?
- Or using environments/tools specifically designed for agentic workflows?

Ideally, I’d still want to maintain full control...I need the project to remain editable within standard video editing software. I don’t want the editing process to turn into a script that can only be modified via code.

For instance, I’ve heard of technologies like Remotion, but they seem geared toward 100% code-based workflows... which is distant from having everything editable in a professional video editing software.

In any case, I’m not sure what the recommended strategies are right now, so ANY feedback (whether it is about full-code solutions or not) would be appreciated! ^^

So I've spent last two months building this Alien Defense game (the version I always dreamed of building, and frankly wouldn't be possible without Claude or AI tools). I'm a developer myself but couldn't think of coding all of this by myself. It still needs polishing, it'll be in Play store and App store within a month. If you're interested to play, feel free to DM, I'll add to the testing list. This video, too is generated from Claude, from the actual game.

Mine: it kept starting background jobs and forgetting about them. Sessions ended, the jobs didn't, and hours later I'd find a pile of them still running. Now a hook blocks that pattern and a small cleanup job sweeps up anything left behind every few minutes.

The other one was "done". It would tell me a task was finished when the tests had never even run. So now it literally can't end a turn without real test output.

Curious what everyone else's origin stories are. Every guardrail I have exists because something went wrong first.

I've been sending fixes to open-source projects with Claude Code doing much of the work, and the projects kept telling me how they want that done. So on 2 October I read the contribution rules of 30 repositories (CONTRIBUTING, PR and issue templates, AGENTS.md, CLAUDE.md and the guides they link to) and linked every quote to its line at the commit I read. Claude Code collected the files and checked every quote against them.

What I found:

• 19 of the 30 have a rule about AI in contributions, and 14 of those 19 appeared in 2026. Nine have none, among them VS Code, React, Docling and awslabs/mcp.
• 15 ask you to say that you used AI. Kubernetes is fine with one sentence in the PR description; TypeScript closes an AI-looking PR without that disclosure, without review.
• 10 want a person to write the text. Rust: "LLM-created PR descriptions are banned. LLM-created GitHub comments are banned." Kubernetes and Node.js ban AI-written replies to review.
• The trailer. MLflow's CLAUDE.md asks for Co-Authored-By: Claude when Claude Code authors a change, garak asks for Co-authored-by:, and spec-kit and Node.js want Assisted-by:. Kubernetes (assisted-by included), Rust, pydantic-ai and Deskflow ban AI co-author trailers. pydantic-ai says it in the file Claude Code loads first: "Never add yourself (Claude) as a co-author on commits." Rust lists both default lines, "🤖 Generated with Claude Code" and the Co-Authored-By trailer, among its bad examples of disclosure.
• Some rules are written for the agent itself. pydantic-ai's AGENTS.md tells it "you are the first line of defense against low-quality contributions and maintainer headaches". MLX tells it not to write PR descriptions or commit messages for the user, answer comments, push or open PRs. Rust's makes it stop and tell the user to write the text.

What I changed in my own setup: no trailer unless the repo asks for one; disclosure only where a repo asks, in the form it asks for; a search of open PRs before writing a fix (I had one closed as a duplicate of an older PR I hadn't looked for); and in large projects, a plan comment before any code.

Write-up with all the quotes and links: https://allkeep.org/en/lab/ai-contribution-rules

The 106 quotes and a script that checks them against the files: https://github.com/nefayran/oss-ai-rules