Os limites de uso para programação com IA estão RIDÍCULOS — veja como continuar escalando

Ver no idioma original →

Autoria: Cole Medin · Assistir no YouTube

Vídeo de autoria do canal indicado, não da IANIA; todos os direitos pertencem ao criador. Transcrição, resumo e tradução gerados automaticamente; o conteúdo no idioma original é preservado na versão em idioma original.

Idioma original: inglês

Vídeo original: AI Coding Rate Limits are RIDICULOUS Now - Here’s How You Keep Scaling Anyway · Canal: Cole Medin · 13:49 · Assistir no YouTube

Tópicos: Agentes de IA, Automação de tarefas e workflows, Engenharia de software com IA, Inferência e otimização de modelos, Modelos locais e open source

Resumo

Cole Medin relata que atingiu rapidamente os limites de uso do Claude Code e do Codex, mesmo sem aumentar muito o trabalho. Para reduzir o consumo de tokens, ele recomenda distribuir as etapas de um workflow de programação com IA entre modelos diferentes: usar os mais capazes para planejar e revisar, e modelos menores e mais baratos para implementar. Ele demonstra essa estratégia com uma software factory e compara versões de um jogo construídas com modelos abertos, Claude e uma combinação de GPT-6 Astra com GLM 5.3 Flash. A combinação de modelos, segundo os testes apresentados, pode reduzir custos e limites consumidos sem prejudicar os resultados.

Pontos-chave

• O apresentador afirma que os limites de uso de Claude Code e Codex estão sendo atingidos mais rapidamente.
• O planejamento é apresentado como a etapa mais importante do workflow de programação com IA.
• Usar modelos menores na implementação pode reduzir o consumo de tokens, pois essa costuma ser a etapa que mais consome.
• O apresentador recomenda reservar os modelos mais capazes para planejamento e revisão.
• Um modelo menor pode implementar bem quando segue um plano detalhado.
• A software factory permite testar combinações de modelos ao longo de um ciclo de desenvolvimento completo.
• Nos testes demonstrados, GPT-6 Astra no planejamento e na revisão, combinado com GLM 5.3 Flash na implementação, produziu um jogo comparável ou melhor que as outras versões, com cerca de quatro vezes menos tokens ou custo.
• A estratégia pode ser adaptada a diferentes ferramentas e workflows; não é necessário usar Archon.

Capítulos

Início	Capítulo	Resumo
00:00	Limites de uso e a necessidade de distribuir o trabalho	O apresentador descreve os limites de Claude Code e Codex e propõe usar modelos diferentes conforme a etapa do workflow.
04:45	Combinação de modelos e demonstração do Scrimba Explain	Ele apresenta sua combinação preferida de modelos, mostra o Scrimba Explain integrado a ferramentas de programação e introduz formas de encadear agentes.
06:22	Workflows com vários modelos e provedores	O apresentador explica como usa Archon, Py e a AI gateway da Neon para passar tarefas entre modelos de planejamento, implementação e revisão.
10:05	Comparação das versões do jogo e resultados	Ele compara versões do jogo feitas com modelos abertos, Claude e uma combinação de GPT-6 Astra com GLM 5.3 Flash, defendendo que não é preciso usar o maior modelo em todas as etapas.

Citações

É ridículo ter que esperar mais três ou quatro dias até a renovação dos meus planos máximos. — 00:30

A etapa mais importante do seu workflow de programação com IA é sempre o planejamento. — 03:42

A implementação costuma ser a parte que mais consome tokens. — 04:15

Você não precisa usar o melhor LLM em todas as etapas do processo. — 13:15

Conceitos e entidades

• Claude Code (ferramenta): Ferramenta de programação com IA cujos limites de uso o apresentador diz ter atingido rapidamente.
• Codex (ferramenta): Serviço de programação com IA citado junto ao Claude Code na discussão sobre limites de uso.
• AI Software Factory (conceito): Sistema apresentado por Cole Medin que automatiza etapas de desenvolvimento, da definição do escopo à validação.
• Archon (repo): Harness builder open source que o apresentador usa para criar workflows com diferentes modelos e provedores.
• DeepSeek V4.1 Flash (modelo): Modelo aberto usado nos testes para planejamento e revisão.
• GLM-5.3-Flash (modelo): Modelo usado principalmente para implementação por ser apresentado como uma opção rápida e barata.
• GPT-6 Astra (modelo): Modelo usado pelo apresentador para planejamento e revisão em sua combinação preferida.
• Claude Fable 5.1 (modelo): Modelo usado nos testes com Claude para construir uma versão do jogo.
• Py (ferramenta): Harness para agent de programação que o apresentador cita como uma forma de acessar modelos abertos.
• Neon (empresa): Empresa cuja AI gateway é usada pelo apresentador para acessar modelos abertos.
• Scrimba Explain (ferramenta): Produto patrocinador do vídeo que gera aulas em vídeo narradas e pode ser usado com Claude Code e Codex.
• Cole Medin (pessoa): Apresentador do vídeo e criador dos testes descritos.

Tradução completa (pt-BR)

00:00 Nesta semana, atingi meu limite de uso do Claude Code muito mais rápido do que nunca, e nem estou fazendo tanto trabalho a mais. Este é meu plano máximo de US$ 200 por mês, e o pior é que também tenho uma assinatura Pro de US$ 200 por mês do Codex, e quase esgotei esse limite também. E os limites dos dois só vão ser redefinidos daqui a mais 3 ou 4 dias. Então, se você achou que era só você que estava atingindo os limites de uso mais rápido, não se preocupe: não é. Estamos todos passando por isso e, infelizmente, já sabíamos que isso estava por vir. Essa tendência vem acontecendo ao longo de todo este

00:30 ano: nossos limites de uso estão piorando. Mas finalmente chegou a um ponto em que não basta eu ser mais eficiente no uso de tokens. Quer dizer, é ridículo eu ter que esperar mais 3 a 4 dias até que os limites dos meus planos máximos sejam redefinidos. Então, no último semestre, tenho feito muitos experimentos com o uso de diferentes modelos, especialmente modelos open source, nos meus workflows de programação com IA. Mas agora isso deixou de ser apenas experimentação e passou a ser: “Ok, preciso absolutamente disso como parte essencial de tudo o que faço”. Quer dizer, veja, a prova está bem aqui. E não sou só eu. Como setor, quando

01:01 nos aprofundamos mais na engenharia de harness e na engenharia de loops, e nas fábricas de software — seja qual for o formato do seu workflow de programação com IA —, estamos tentando ampliar a produção com nossos agents de programação. Mas agora, mais do que nunca, o maior limite é simplesmente a quantidade de tokens que podemos gastar. Por isso precisamos planejar e descobrir, nos workflows de programação com IA maiores, não com um único agent, onde realmente precisamos do LLM maior e mais capaz e onde podemos usar algo menor, mais barato e mais rápido, obtendo basicamente o mesmo resultado. E sim, isso é possível. Acredite, passei a semana mergulhado no

01:33 laboratório, expandindo toda a pesquisa que venho fazendo neste ano e tentando descobrir, em um workflow tradicional de programação com IA, com planejamento, implementação, validação e revisão, onde precisamos do melhor LLM e onde não precisamos. Essa é a grande pergunta a responder agora, para você não atingir o limite de uso três dias depois da redefinição semanal. Para todos os testes que fiz nesta semana, usei minha fábrica de software com IA. Tenho falado bastante desse sistema recentemente no meu canal. Ele reúne minhas melhores práticas de programação com IA, com planejamento, implementação e validação. E empacota tudo em um

02:05 sistema completo no qual posso enviar um escopo de trabalho e ele simplesmente constrói e valida tudo sem que eu precise participar. É o teste definitivo de quão autônoma a programação com IA pode ser sem deixar de ser confiável. Mas, mais importante para este vídeo, isso me permite testar com muita facilidade diferentes combinações de modelos de linguagem grandes ao longo de todo o ciclo de desenvolvimento. Então, o que venho fazendo é construir vários aplicativos diferentes com a fábrica de software com IA, incluindo este videogame que vou mostrar hoje. Ele serve como um exemplo central bem visual. Mas, em todos os outros projetos que

02:36 construí, os resultados foram praticamente os mesmos que obtive com as diferentes combinações para este jogo. Então, construí o mesmo jogo apenas com modelos open source, com Claude e com Codex. Também fiz muitos outros testes, mas estas são as três categorias principais. Basicamente, escolhi o melhor modelo de cada grupo, certo? Entre os modelos open source, o DeepSeek V 4.1 Flash é praticamente o melhor dos melhores. Então, se você olhar os benchmarks de LLM ao vivo aqui, entre os modelos open source com essa tag, o DeepSeek V 4.1 Flash é o melhor no momento. E, para Claude, o Claude Fable 5.1 Max Effort

03:10 é o melhor. E, para Codex, o GPT-6 Astra Max Effort é o melhor. Então, voltando aos meus testes principais, com os modelos open source, estou usando o DeepSeek Flash para planejamento e revisão e, depois, o GLM 5.3 Flash para implementação. Na verdade, fiz um teste de referência usando-o para implementação em todos os testes. E, para Claude, estou usando o Fable para planejamento e revisão. Já para Codex, estou usando o Astra. O mais importante aqui é que vocês vão notar que sempre uso o LLM mais capaz para planejar e revisar e, depois, um modelo menor para construir. Foi algo que determinei durante minha

03:42 experimentação desta semana e também em muitos dos testes que fiz no início deste ano. A etapa mais importante do seu workflow de programação com IA é sempre a etapa de planejamento. Se você tiver um plano bem escrito e a pessoa ou o modelo que implementa segui-lo, o LLM nem precisa ser tão capaz para chegar a praticamente os melhores resultados possíveis. Certo? Usar o Fable para planejamento e implementação, por exemplo, dá praticamente os mesmos resultados que usar o Fable para planejamento e o Sonnet para implementação. Então, vocês vão ver isso aplicado de propósito em todos os testes que vou mostrar hoje. E, a propósito, a implementação geralmente

04:15 é a parte do seu workflow que mais consome tokens. Então, usar o modelo menor nessa etapa é o que nos impede de atingir nossos limites de uso muito rápido. Agora, é claro que, para alguns trabalhos muito difíceis e pouco explorados, talvez você queira usar um modelo grande para tudo. E eu não faço isso na minha fábrica de software, mas, se houver uma pessoa no processo e as tarefas forem muito pequenas e bem delimitadas, você pode usar um modelo open source para literalmente tudo. Então, diferentes combinações fazem sentido em diferentes situações, mas esta é a recomendação geral. E vou mostrar muitos dos meus testes que

04:45 me levaram a isso, mas, para mim, meu fluxo favorito no momento, minha combinação favorita, é usar o GPT-6 Astra para o planejamento e a revisão e, depois, o GLM 5.3 Flash para uma implementação super-rápida e barata. Este é meu workflow principal para tudo o que estou fazendo agora com minha fábrica de software e até fora dela. O patrocinador do vídeo de hoje é a Scrimba, e eles acabaram de lançar algo incrível chamado Explain. Você faz uma pergunta e, em 2 a 3 segundos, recebe uma aula em vídeo totalmente narrada, criada ao vivo enquanto você assiste, e que se integra

05:18 diretamente ao Codex e ao Claude Code. Então, agora, no Claude Code, digito {slash} MCP e vejo que o Scrimba Explain está conectado. Bastou um único comando para fazer isso. Agora posso pedir ao Claude Code que crie uma explicação sobre qualquer coisa. Achei que seria uma demonstração legal mostrar a criação de uma explicação no Scrimba para um pull request mais complicado do meu projeto open source Arkon. Aqui, o Claude lê as diferenças, prepara a aula e depois a transmite para o Scrimba, slide por slide. Então recebo o link na hora e posso assistir enquanto ele cria a explicação. E preciso dizer que a explicação que recebi

05:50 no final realmente me impressionou. Deixa eu mostrar. Este é o pull request original para o qual pedi a explicação. E aqui está o vídeo. Vou ficar quieto por um instante e reproduzir alguns trechos. “O PR 3416 oferece a três adaptadores uma forma compartilhada de…” >> “Vou passar para um diagrama mais geral aqui.” >> “…é o contrato implementado pelo adaptador da CLI e pelo adaptador da web.” >> E também entra nos detalhes do código. Deixa eu avançar um pouco. >> “…fica no núcleo. O helper aceita qualquer objeto, o que permite que a plataforma sem interface passe seu trabalho estruturalmente idêntico…” Então, obviamente, não vou reproduzir tudo

06:22 mas, sim, ficou ótimo. Ele está explicando tudo de um jeito bem simples e claro. Adorei. O Explain também funciona no ChatGPT e como extensão do Chrome para qualquer artigo. Experimente o Explain gratuitamente pelo link na descrição. Agora, talvez você esteja se perguntando: como exatamente criamos um workflow de programação com IA maior usando diferentes modelos e provedores? Talvez você queira implementar do mesmo jeito que eu, fazer experimentos como eu, ou qualquer outra coisa. Há muitas maneiras diferentes de fazer isso. A forma mais manual, mas simples, é simplesmente ter cada agent de programação

06:53 gere um documento de transferência em Markdown, para você passar ao próximo modelo ou ao próximo coding agent. Assim, você pode simplesmente ir de um em um, abrindo sessões diferentes com coding agents. Também existem harnesses como o Omnigen, que facilitam muito trabalhar com modelos e diferentes provedores dessa maneira. Mas, para minha fábrica de software de IA e meus workflows de programação em geral, eu simplesmente uso meu construtor de harness open source, o Archon. Ele facilita muito a criação desses workflows que executei centenas de vezes na última semana para combinar diferentes modelos e provedores.

07:27 Então, para cada teste que executei, cada combinação de modelos, o formato do workflow no Archon é sempre este. Daqui a pouco vou mostrar como são os workflows. A entrada é sempre uma issue do GitHub que descreve o que queremos construir. Depois, peço ao modelo mais poderoso que faça o planejamento, como o GPT-6 Astra, que é meu favorito. Pegamos esse plano e, dentro do workflow do Archon, passamos automaticamente para o próximo nó, no qual o GLM 5.3 Flash faz a implementação. Depois, o Astra faz a revisão e envia de volta ao GLM quaisquer problemas encontrados para que ele os corrija, e temos esse

07:59 ciclo, obviamente com um número máximo de tentativas. Depois, no final, fazemos a verificação, que consiste simplesmente em executar nossos testes e garantir que a compilação esteja passando antes de fazer o merge no fim da fábrica de software. Então, este é um workflow de programação com IA bem tradicional. Nada de extraordinário. Este é exatamente o formato de todos os testes que executei. Também há muitas maneiras diferentes de acessar modelos open source para nossos workflows de programação com IA, mas meu favorito recentemente, especialmente porque o Archon oferece suporte a ele, é usar o Py como agent harness de programação com IA. E, para acessar os LLMs, usar o gateway de IA da Neon. Eu

08:32 sempre gostei da Neon. Adoro a solução de banco de dados Postgres deles. Eles vêm adicionando vários outros recursos de IA muito legais, como o gateway de IA, além de todos os novos recursos de backend, como armazenamento de objetos, autenticação e funções. Mas, sim, por enquanto estou usando o gateway de IA, que nos dá acesso muito confiável e pelo custo, praticamente a todos os modelos open source que poderíamos querer. Por exemplo, temos o Kimiko 3. O que mais temos aqui? Temos o GLM 5.3 Flash, de que tenho falado bastante. Então, esta é minha maneira simples de acessar todos os modelos de que preciso nos meus workflows do Archon e com o Py. Mas

09:02 independentemente de como estou acessando esses modelos open source, o importante é que estou fazendo isso. Não estou usando apenas o Astra ou o Fable para tudo, como muitos de nós somos tentados a fazer. E você pode configurar isso com qualquer coisa. Nem precisa do Archon. É minha ferramenta, é gratuita e open source, e eu a uso para executar a fábrica de software de IA. Mas também não estou dizendo que você precisa usar minha ferramenta, certo? Isso é simplesmente o que venho fazendo nos meus testes para apresentar esses resultados e ajudar você a pensar em quais modelos usar e em quais combinações. Então, nos meus workflows do Archon, esta é uma visão um pouco simplificada, mas praticamente todos eles são assim, certo? Temos

09:35 primeiro a etapa de planejamento, em que usamos o modelo mais poderoso. Depois, usamos o documento do plano em Markdown como transferência para a etapa de construção, com um modelo mais barato, como o GLM 5.3 Flash por meio da Neon; em seguida, fazemos a revisão novamente com um modelo mais poderoso e corrigimos tudo o que foi apontado usando o modelo mais barato. Este é o formato, além dos meus testes aqui, de como geralmente trabalho com coding agents agora. Certo, eu queria dedicar um bom tempo a explicar meu workflow, meus testes e os modelos que recomendo, mas agora quero entrar no jogo em si como o exemplo principal

10:05 aqui, só para dar a você uma ideia visual dos resultados que obtive com todos os diferentes aplicativos que venho construindo. Mais uma vez, como eu disse no começo do vídeo, esses resultados foram praticamente os mesmos, independentemente do que eu estivesse construindo. Então, a primeira versão do jogo ficou horrível. Você provavelmente consegue adivinhar que foi o que construí usando apenas modelos open source. Aliás, este jogo foi ideia de um amigo. É muito legal, então achei que valia a pena passá-lo pela fábrica. É um jogo de perseguição a tempestades, tipo um jogo de caça a tempestades em Netuno. Na verdade, é multijogador. Pessoas diferentes podem entrar e operar as estações aqui. Não vou configurar isso agora, mas o jogo que ele nos entregou com aquele PRD à fábrica de software é bem completo

10:37 Então, nesta versão do jogo, usei modelos open source: DeepSeek v4.1 Flash para o planejamento e a revisão e, para a construção, usei o GLM 5.3 Flash. Os visuais são tão ruins que mal dá para perceber que estou me movendo. Dá para ver algumas nuvens do lado de fora das janelas, mas, sim, dá para ver o rumo mudando no canto superior esquerdo enquanto eu, como piloto, viro. Mas, no geral, isso nem é um bom ponto de partida para um jogo. Já a próxima versão do jogo foi construída inteiramente com o Claude, porque

11:08 eu queria mostrar um exemplo em que não usamos modelos open source. Usei o Claude Fable 5.1 para construir tudo isso. E, sim, por causa dos tokens, não dava para fazer algo supercompleto, então infelizmente não consegui criar algo que fosse superbonito, mas, quer dizer, ainda ficou bem legal. Com certeza, muito melhor do que apenas com os modelos open source. Vou até o piloto aqui. Queria poder correr, mas vou até o piloto e mostrar que as coisas estão bem melhores. Se eu pegar os controles e mudar o rumo, você vai ver que, quer dizer, fica um pouco

11:39 truncado, mas estou me movendo na direção das nuvens e, quando avanço, elas realmente ficam mais perto. A navegação pelo planeta está funcionando bem aqui. Seria legal mostrar todas as outras estações também, mas isso levaria muito tempo. O importante é que o Claude Fable 5.1 fez um bom trabalho para a prova de conceito inicial deste jogo. Não permiti muitos tokens, mas, sim, ficou bem legal. A próxima versão do jogo me impressionou de verdade. Não que seja algo realmente incrível, mas o fato é que usei o GLM 5.3 Flash para escrever cada linha

12:12 de código desta versão do jogo. Para o planejamento e a revisão, usei o GPT-6 Astra. E esta versão do jogo custou cerca de quatro vezes menos em tokens, ou teve um custo total menor, porque usei o GLM para a implementação. A jogabilidade é praticamente a mesma. Na verdade, o movimento fica ainda mais suave aqui quando vou em direção às nuvens. Eu diria que esta versão do jogo é até melhor, mesmo tendo usado um modelo open source para escrever cada linha de código. Claro que ajuda ter a revisão do Astra, mas ainda estou economizando muito

12:45 nos custos e nos limites de uso ao usar esta combinação de modelos. Então, sim, é um jogo meio bobo, basicamente uma prova de conceito, mas o importante é que esses foram os resultados que obtive em praticamente todos os aplicativos que construí. E lembre-se: voltando ao LiveBench, o Claude Fable 5.1 e o GPT-6 Astra são bem próximos em capacidade. Então, é muito legal termos conseguido criar um jogo um pouco melhor e outros aplicativos com essa combinação, em comparação a usar apenas o Claude. Essa é a prova de que você precisa. Você

13:15 nem sempre precisa usar o melhor LLM em todas as etapas do seu processo. Vale muito a pena dedicar tempo, e espero ter provado isso aqui, para analisar seu workflow de programação com IA e descobrir em quais etapas você precisa do melhor modelo e em quais não precisa, porque é isso que vai evitar que você estoure os limites de uso das suas assinaturas, como as do Claude e do Codex. Então, minha fábrica de software de IA é como venho fazendo todos os meus testes e como executo meus workflows agora, mas essa lição também se aplica ao que quer que você esteja fazendo atualmente. Você realmente deveria explorar os modelos open source neste momento, porque está ficando claro

13:49 que nem sempre podemos executar em nossos modelos de fronteira. Então, espero que você tenha achado interessante acompanhar esses testes. Estou passando por todas essas combinações diferentes e desenvolvendo aplicativos diferentes. Se achou, eu agradeceria muito se deixasse uma curtida e se inscrevesse no canal. Acompanhe enquanto continuo desenvolvendo minha fábrica de software e testando essas combinações. E, com isso, vejo você no próximo vídeo.

Transcrição original

[00:00] This week, I’ve hit my Claude Code rate limit way faster than I ever have before, and I’m not even doing that much more work. This is my max $200 a month plan, and the worst part is, I also have a $200 month Pro subscription for Codex, and I’ve almost exhausted that limit as well. And both of them aren’t going to reset for another 3 or 4 days. And so, if you thought it was just you hitting your rate limits faster, don’t worry, it’s not. We’re all suffering from this, and unfortunately, we knew this was coming. It’s been a trend this entire

[00:30] year, our rate limits getting worse. But it’s just finally come to a point where I can’t just be more efficient with my token usage. I mean, it’s ridiculous that I have to wait 3 to 4 more days before I even have a reset on my max plans. So, over the past half year, I’ve been doing a lot of experimentation with using different models, especially open ones, in my AI coding workflows. But now, that’s gone from just experimentation to, “Okay, I absolutely need this as a crucial part of everything that I’m doing.” I mean, look, the proof is right here. And that’s not just me. As an industry, when

[01:01] we get more into harness engineering and loop engineering and software factories, whatever your AI coding workflow looks like, we’re trying to scale the output with our coding agents. But now, even more than before, the biggest limit is just the number of tokens that we can spend. That is why we need to strategize and figure out for our larger AI coding workflows, not single agent, where do we absolutely need the largest and most capable LLM versus other places where we can use something that is smaller, cheaper, faster, and still get basically the same output And yes, that is possible. Trust me, I’ve been deep in

[01:33] the lab this week, expanding on all the research I’ve been doing this year, figuring out for a traditional AI coding workflow where you have your planning, implementing, validating, and reviewing, where do we need the best LLM versus where do we not? That’s the big question to answer right now, so you don’t hit your rate limit 3 days into your weekly reset. So, for all the testing that I’ve done this week, I’ve done it with my AI software factory. I’ve covered this system a lot on my channel recently. It takes all my best practices for AI coding with planning and implementing and validating. It packages it up into a

[02:05] complete system where I can send in a scope of work and it just builds and validates everything without me in the loop at all. It’s the ultimate test of how autonomous can we make AI coding while still keeping it reliable. But more importantly for this video, it allows me to very easily test different combinations of large language models with the full development cycle. So, what I’ve been doing is building a bunch of different applications with the AI software factory including this video game that I’ll show you today. It just makes for a nice and visual core example. But all the other things that I

[02:36] built, the results I got is pretty much the same as what I got with the different combinations for this game. So, building the same game but with only open models using Claude and using Codex. A lot of other testing that I did as well, but these are the three core columns. And so, essentially I just took the best model from each group, right? With open models, DeepSeek V 4.1 Flash is pretty much the best of the best. So, if you look at like the live LLM benchmarks here, as far as open models go with that open tag, DeepSeek V 4.1 Flash is the best right now. And then for Claude, Claude Fable 5.1 Max Effort

[03:10] is the best. And then for Codex, GPT-6 Astra Max Effort is the best. And so, going back here for my core testing with open models, I’m using DeepSeek Flash for planning and reviewing and then GLM 5.3 Flash for the implementation. And I actually did this as a baseline where I used it for implementation for every single test. And then for Claude, using Fable for planning and reviewing. And then for Codex, using Astra. The most important thing here is you’ll notice I’m always using the more capable LLM for planning and reviewing and then the smaller model for building. This is something that I’ve determined in my

[03:42] experimentation this week and a lot of what I was doing earlier this year as well. The most important step of your AI coding workflow is always the plan step. If you have a well-written plan, the implementer following that, it doesn’t even have to be that capable of an LLM to pretty much get the best results possible. Right? Like using Fable for planning and implementation gets you essentially the same results as using Fable for planning and Sonnet for implementation. So that you’ll see that very intentionally laid out in all the testing I show you today. And by the way, for implementation, generally

[04:15] that’s the most token-heavy part of your workflow. So for using the smaller model for that, that is what prevents us from hitting our rate limits super quickly. Now, obviously for some work, if it’s very, very difficult and unexplored, you might want to use a large model for everything. And I don’t do this in my software factory, but if you do have human in the loop, really small and bounded tasks, you can use an open model for literally everything. So, there’s different combinations that make sense in different situations, but this is generally what I recommend. And I’ll show you a lot of my testing that has

[04:45] led to this, but for me, my favorite flow right now, my favorite combination, is to use GPT-6 Astra for the planning and the review, and then GLM 5.3 Flash for the super fast and cheap implementation. This is my core workflow for everything that I’m doing right now with my software factory and even outside of that. The sponsor of today’s video is Scrimba, and they just released something incredible called Explain. You ask a question and it gives back a fully narrated video lesson in 2 to 3 seconds, built live while you watch, and it plugs

[05:18] right into Codex and Claude Code. So now over in Claude Code, I do {slash} MCP, we can see I have Scrimba Explain connected. It was just a single command to do this. And so now I can ask Claude Code to make an explainer for anything. And so I thought this would be a neat demo here to show it making a Scrimba explainer for a more complicated pull request from my open-source project Arkon. So here Claude reads the diff, it builds up the lesson, and then it streams to Scrimba slide by slide. So I get the link right away, I can watch it as it builds the explainer. And I got to say, the explainer that I got back here

[05:50] at the end, it genuinely impressed me. Let me show you. So, this is the original pull request that I made the explainer for. And then here is the video. So, I’ll just shut up for a second and play a couple of the clips here. PR 3416 gives three adapters one shared way >> I’ll go to a more high-level diagram here. >> is the contract that the CLI adapter and the web adapter implement. >> And it goes into the code as well. Let me click a little bit further here. >> lives in core. The helper accepts any object, which lets the headless platform pass its structurally identical work >> So, I’m not going to play the entire

[06:22] thing, obviously, but yeah, it sounds great. And it’s breaking things down really nice and simple for me. I love it. Explain also works from ChatGPT and as a Chrome extension for any article. Give Explain a try for free with my link in the description. Now, the question you might have at this point is how exactly do we build a larger AI coding workflow where we’re using different models and providers? Cuz maybe you want to implement the same way I am, you want to experiment like I am, whatever it is. There are a lot of different ways you can do this. The most manual, but simple way is just to have each coding agent

[06:53] output a handoff document as markdown, so you feed that into the next model or the next coding agent. And so, you could just go through one at a time, opening up different coding agent sessions. There are also harnesses out there like Omnigen that make it very easy to work with models and different providers in this way. But what I do for my AI software factory and my coding workflows in general, is I simply use my open source harness builder Archon. This makes it really easy for us to build these workflows that I’ve been running hundreds of times the last week to combine different models and providers.

[07:27] So, for every single test that I ran, every single combination of models, the shape always looks like this as an Archon workflow. And I’ll show you what the workflows look like in a little bit. So, the input is always a GitHub issue that describes what we want to build. Then I have the most powerful model do the planning like GPT-6 Astra as my favorite. We take that plan, and then within the Archon workflow, we automatically pass that into the next node, which is GLM 5.3 Flash doing the implementation. Then, we have Astra review, and then any findings it sends back to GLM to correct, and we have that

[07:59] loop with obviously max retries. And then, we have the check at the end, which is just running our tests, making sure the build is green before we do the merge at the end of the software factory. And so, this is a pretty traditional AI coding workflow. There’s nothing crazy here. This is the exact shape for every single test I ran. There are also a lot of different ways to access open models for our AI coding workflows, but my favorite recently, especially cuz Archon supports this, is to use Py as the AI coding agent harness. And then, for accessing the LLMs, using Neon’s AI gateway. I’ve

[08:32] always loved Neon. I love their Postgres database solution. They’ve been adding a lot of other really cool AI features as well like AI gateway and all their other new back-end features like object storage, authentication, and functions. But yeah, for right now, I’m using AI gateway, which gives us really reliable and at-cost access to pretty much every open model that you could hope for. So, for example, we have Kimiko 3. Uh what else do we have here? We have GLM 5.3 Flash, which I’ve been talking about a lot. And so, this is just my easy way to access all the models that I need within my Archon workflows and with Py. But

[09:02] regardless of how I am accessing these open models, the important thing is that I am. I’m not just using Astra or Fable for everything like a lot of us are tempted to do. And you can do the setup with anything. You don’t even need Archon. It’s my tool. It’s free and open source, and I use it to run the AI software factory. But also, I’m not telling you have to go use my tool at all, right? Like this is just what I’ve been doing for my experimentation to give these results to you and help you think about what models to use, what combination. And so, for my Archon workflows, this is a bit of a simplified view, but pretty much every single one of them looks like this, right? We have

[09:35] the planning step at first, where we’re using the more powerful model, and then we take that plan markdown document as a handoff to go into the build step with the cheaper model like GLM 5.3 flash through neon, and then review with more powerful again, and then fix anything that came up with the cheaper model. This is the shape, even beyond my experimentation here, for just generally how I work with coding agents now. Okay, so I wanted to spend good time explaining my workflow, my experimentation, and the models that I recommend, but now I want to get into the actual game with you as the core

[10:05] example here, just to give you a visualization of the results that I’ve been getting across all the different apps I’ve been building. This, again, like I said at the start of the video, is very much the results I got no matter what I was building. And so, the first version of the game looks terrible. You can probably guess this is what I built with only open models. And so, by the way, this game is an idea from a friend. It’s really cool, so I thought I’d put this through the factory. It’s a weather chasing, like storm chasing game on Neptune. It’s actually multiplayer. You can have different people join and man the stations here. I won’t set that up right now, but it’s pretty comprehensive

[10:37] game that it gave us that PRD into the software factory. And so, this version of the game, I used open models, so DeepSeek v4.1 flash for the planning and reviewing, and then for the building I used GLM 5.3 flash. Now, the visuals are so bad you can’t even really tell that I’m moving. There’s a couple of clouds you can see outside the windows, but yeah, we can see the heading changing in the top left as I’m turning around as the pilot. But overall, this isn’t even really a good starting point for a game. And then for the next version of the game, this one was built entirely with Claude, because

[11:08] I wanted to show you an example here where we aren’t using open models at all. I used Claude fable 5.1 to build this entire thing. And yes, for the sake of tokens, I couldn’t do something super comprehensive, so I unfortunately wasn’t able to make something that looks like super beautiful, but I mean, this still looks pretty good. Definitely a lot better than just the open models. And let me go over to the pilot here. I wish I could run, but I’ll go over to the pilot and show you that things look a lot better. Like if I take the controls here and I change the heading, you’ll see that like I mean it’s a little bit

[11:39] choppy, but I’m moving towards the clouds and then when I go forward, the clouds are actually getting closer. Like the navigation on the planet is actually working pretty well here. It’d be cool to show you all the other stations as well, but it would take a lot of time. The point is that Claude Fable 5.1, it did a pretty good job for the very initial proof of concept for this game. I didn’t allow that many tokens, but yeah, it’s pretty good. The next version of the game, I am genuinely impressed. Not that it’s like actually amazing, but the fact is I used GLM 5.3 Flash to write every single line

[12:12] of code in this version of the game. And then for the planning and reviewing, I used GPT-6 Astra. And so this version of the game was about four times less tokens or like less cost overall because I’m using GLM for the implementation. And it plays pretty much the same. Actually, the moving is even smoother here going towards the clouds. I would say this version of the game actually is better even though I was using an open model to write every single line of code. So, of course, it helps to have Astra review, but I’m still saving a ton

[12:45] on my cost/rate limit by using this combination of models. And so, yeah, a little bit of a cheesy game, very much just a proof of concept, but the point here is this is the results that I got for pretty much every application that I built. And remember, going back to the live bench here, Claude Fable 5.1 and GPT-6 Astra, they’re pretty close in capability. And so, it’s pretty awesome that we were able to build even a little bit of a better game and other apps with this combination compared to just using Claude. That is the proof you need. You

[13:15] don’t always have to have the best large language model for every step of your process. It is well worth your time, and I hope I’ve really proved it here, to analyze your AI coding workflow, figure out where you need the best model and where you don’t because that is what’s going to prevent you from jacking up your rate limits for your subscriptions like Claude and a Codex. And so, my AI software factory is how I’ve been doing all my testing, how I run my workflows now, but it whatever you’re currently doing, this this lesson applies. Like you should really explore open models at this point because it’s becoming clear

[13:49] that we can’t always run on our frontier models. So, hopefully you found this testing interesting. As I’m going through all these different combinations, building out different apps. If you did, I would really appreciate a like and a subscribe. Follow along as I continue to build out my software factory and test these combinations. And with that, I will see you in the next video.