Purr Request: unlazy — Claude Code foi melhor sem ele

Autoria: The Gray Cat · 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: Purr Request: unlazy — Claude Code Did Better Without It · Canal: The Gray Cat · 09:14 · Assistir no YouTube

Tópicos: Agentes de IA, Avaliação e benchmarks de IA, Claude Code, Ferramentas de desenvolvimento com IA

Resumo

O vídeo compara Claude Code com e sem a skill unlazy em uma pequena tarefa de melhoria de interface, usando o mesmo prompt e Opus 5.5. A versão sem unlazy terminou mais rápido, usou menos tokens e implementou melhor algumas ações solicitadas. Embora unlazy tenha criado uma checklist e tornado verificações incompletas visíveis, uma de suas checagens passou sem confirmar se a remoção de scripts pelo teclado funcionava. O teste sugere cautela ao adicionar ferramentas a modelos e harnesses que estão evoluindo, mas o apresentador ressalva que unlazy pode ser mais útil em tarefas maiores ou com o Stop hook instalado.

Pontos-chave

O teste comparou duas worktrees com o mesmo prompt e Opus 5.5, usando Ponytail Ultra em ambas.
A tarefa era melhorar a página inicial e permitir excluir arquivos selecionados com a tecla Delete ou por um botão.
A execução sem unlazy levou menos tempo e consumiu menos tokens e custo de API.
Astra considerou que a execução sem unlazy venceu o teste.
A checklist de unlazy foi aprovada sem a confirmação do usuário, embora o apresentador acreditasse que deveria aprová-la.
Uma checagem de unlazy procurava palavras no código e passou, mas não verificou corretamente a ação de excluir scripts pelo teclado.
O Stop hook opcional, que deveria impedir a conclusão com verificações pendentes, não foi instalado.
O apresentador observa que ferramentas feitas para versões anteriores do Claude Code podem não funcionar tão bem com modelos e harnesses mais novos.
O resultado se aplica a uma pequena mudança de interface; unlazy ainda pode ser útil em tarefas maiores ou com configurações diferentes.

Capítulos

Início	Capítulo	Resumo
00:00	O que é unlazy e como será o teste	O apresentador explica a proposta da skill e prepara uma comparação entre duas execuções com o mesmo prompt.
02:34	Comparação das duas execuções	As duas versões recebem a tarefa de melhorar a interface e implementar a exclusão de arquivos.
05:37	Avaliação dos resultados e falhas de verificação	Astra avalia as implementações, e o apresentador observa que unlazy consumiu mais recursos e deixou uma ação de teclado sem funcionar.
08:11	O que o teste ensina sobre ferramentas adicionais	O apresentador detalha as limitações da checklist, ressalva que não testou alguns recursos e conclui que unlazy não ajudou nesta tarefa.

Citações

Claude Code foi melhor sem ela. Usou menos tokens e construiu mais do que eu pedi. — 00:00

unlazy é um conjunto de instruções mais um pequeno script de verificação. — 01:32

Às vezes, menos ferramentas é melhor. — 07:40

Estou ficando um pouco relutante em instalar essas coisas sem verificar o que elas realmente fazem por mim. — 09:14

Conceitos e entidades

unlazy (ferramenta): Uma skill para Claude Code e Codex que usa instruções e um script de verificação para tentar evitar que o agent encerre tarefas incompletas.
Claude Code (ferramenta): Ferramenta de programação usada no vídeo para executar a tarefa com e sem unlazy.
Codex (ferramenta): Ferramenta de programação para a qual unlazy também é apresentada como uma skill.
Opus 5.5 (modelo): Modelo usado nas duas execuções comparadas.
Ponytail Ultra (ferramenta): Configuração usada nas duas execuções para influenciar principalmente estilos de código e verbosidade.
Astra (ferramenta): Ferramenta usada para testar as implementações e avaliar os resultados.
RTK (ferramenta): Ferramenta citada como outro caso em que uma execução sem a ferramenta usou menos tokens.
Depth Tree (ferramenta): Recurso mencionado pelo apresentador que divide tarefas maiores em partes menores.

Tradução completa (pt-BR)

00:00 Testei o unlazy em uma pequena mudança na UI, e o Claude Code se saiu melhor sem ele. Usou menos tokens e construiu mais do que pedi. unlazy é uma skill para Claude Code e Codex com cerca de três mil e quinhentas estrelas no GitHub. A ideia é impedir que o agent deixe o trabalho inacabado. Antes de programar, o agent escreve uma lista de verificação em GATES.md, com uma forma de conferir cada item. Depois, deve continuar trabalhando até que essas verificações sejam aprovadas. Estou testando um novo formato chamado Purr Request,

00:30 em que pego um repo do GitHub e experimento. Para este, segui o início rápido e acrescentei /unlazy ao meu pedido. Não tinha lido toda a documentação. Dei o mesmo prompt para o Opus 5.5 em duas worktrees, com o unlazy instalado em uma delas. As duas também estavam com o Ponytail Ultra em execução, então estamos testando o que o unlazy acrescenta a essa configuração. Vou mostrar o bug que ele não detectou e por que a verificação foi aprovada mesmo assim.

01:02 Certo, desta vez vamos experimentar a skill unlazy. Acho que já vi essa skill há algum tempo em alguns canais do YouTube, mas nunca tive a chance de testá-la. Tentei entender esta documentação, mas, aparentemente, ela foi escrita com o Opus 5, e o Opus 5 não é o melhor modelo para escrever documentação; ela é cheia de gates. Você pode me explicar o que essa skill faz em linguagem simples?

01:32 Certo, ainda é uma parede de texto, mas talvez uma parede de texto um pouquinho menor. unlazy é um conjunto de instruções mais um pequeno script de verificação. Ele impede que um agent de programação com IA diga que terminou antes de o trabalho estar realmente concluído. É, parece exatamente o que a gente precisa. Quer dizer, provavelmente não se encaixa muito bem no workflow de SDD existente, mas, se você simplesmente usar prompts, parece que é sempre melhor executar o prompt com unlazy.

02:03 Mas, de novo, precisamos descobrir se isso é mesmo verdade e quanto tempo leva em comparação com uma execução sem modificações. Então, acho que agora vou instalar essa coisa e, no Orca, criei duas worktrees novas. Vou colar este comando e instalar essa coisinha. Certo, as configurações padrão parecem boas, então acho que posso simplesmente executar

02:34 o Claude Code de novo e deixar o unlazy aqui. Certo, ótimo. O que eu quero tentar fazer, se eu executar o The Gray Cut aqui, é que não gosto muito da aparência desta UI. Gostaria de melhorar a página inicial deste app. Não gosto de não poder excluir arquivos depois de adicioná-los. A única maneira de excluir um arquivo é reiniciar o app e arrastá-los para lá.

03:05 Quero que seja possível excluí-los. Quando eu os selecionar e apertar Delete, eles devem simplesmente desaparecer. E talvez pudesse haver um botão X à direita. No geral, acho que o layout não é muito amigável nem acolhedor, então, se você conseguir pensar em algo que o torne mais fácil de usar, seria muito, muito melhor. Então, é isso. Este prompt. E nesta aba, quero dar exatamente o mesmo prompt. Ah, sim.

03:36 A propósito, estou usando o Ponytail aqui, então acho que não deve afetar muita coisa. Principalmente estilos de código e verbosidade, mas não vou removê-lo, certo? Acho que vou ficar de olho nele aqui e responder a quaisquer perguntas para desbloquear o progresso. Não vou usar nenhum modo de planejamento nem qualquer outro framework; só vou ver como vai. Conferindo o que está acontecendo aqui, parece que a coisa do unlazy, a worktree com unlazy,

04:06 foi direto para a escrita do código. Aqui também. Mas, opa, temos algo. Consegui. Compila. A execução sem unlazy terminou em dois minutos. Então, o que há de novo na tela inicial? Agora dá para excluir arquivos. Clique em um arquivo e aperte Delete. Ele some. É, isso já ficou um pouquinho melhor. Sim, definitivamente ficou melhor.

04:36 Gostei bastante, e levou dois minutos sem planejamento. A propósito, é o Opus 5.5. Ainda não tinha trabalhado muito com esse modelo, mas, em dois minutos, ele fez melhorias bem visíveis. Excluir. Isso funciona. E esta coisinha também funciona. Sim, foi exatamente isso que eu queria que ele construísse. E esta parte também está pronta. Fiz a mudança na tela inicial. A compilação foi aprovada. Eu não cliquei

05:06 em tudo para testar. Ah, esta versão ficou um pouco pior. Gosto do botão de execução aqui. Acho que a ideia é basicamente a mesma. O ícone está laranja aqui, e o alinhamento do ícone está um pouco errado. Fora isso, parece funcionar. Isso funciona, isso funciona, isso exclui. Acho que agora preciso executar uma instância dedicada do Astra e verificar a qualidade da implementação e o resultado.

05:37 Então, estou com o Astra high aqui. Pode começar. É, vou fazer uma pausa aqui. Certo, ótimo. O Astra ficou clicando por aí e, por fim, chegou a um veredito. E, segundo esse veredito, surpreendentemente, a execução sem unlazy venceu este teste. Olhando a tabela, com unlazy a execução levou mais 30 segundos. Usou um pouco mais de tokens. 19%.

06:09 Essas são coisas nerds. Leituras do cache. Mais leituras do cache. Mais de tudo. É, obviamente, a execução usou mais porque teve mais de tudo, incluindo o custo equivalente de API. Quase gastamos um dólar com unlazy, mas só 80 centavos sem unlazy. É, olhando para isso, acho que ele reclamou de alguma coisa. Então, nas duas versões: a compilação foi aprovada, selecionar uma take e apertar Delete funciona.

06:40 Na versão sem unlazy: selecionar um script e apertar Delete também funciona. A remoção pelo X da take funciona. Ah, eu nem pensei em testar a remoção do script. Talvez eu devesse usar este Astra para testar coisas no futuro. Ele encontra algumas coisas inesperadas. unlazy produziu três gates aprovados e um gate de UI inacabado. Ah, estamos produzindo gates de novo. Astra, que vergonha.

07:10 Isso deixou visível que a verificação estava incompleta, mas não impediu que a execução terminasse sem estar completa. As duas implementações também deixam inalteradas as referências dos projetos salvos quando os arquivos são removidos depois de uma execução que falhou ou foi cancelada. Então, ao reabrir, esses arquivos aparecem de novo. Interessante. Não é uma questão do Ponytail, mas do novo modelo e do harness em constante evolução. E essas ferramentas parecem ter sido criadas para versões anteriores do Claude Code,

07:40 como o Opus 5, meu favorito, e versões anteriores. E agora saiu essa coisa nova e ela já não funciona. Então, você sempre precisa ter em mente a regra de que menos é mais. Talvez agora menos ferramentas sejam, na verdade, mais. Depende, com certeza depende. Mas há uma grande chance de as ferramentas antigas não funcionarem com os modelos novos. Então, não se apresse para instalar tudo. Igual ao RTK, né?

08:11 Agora, as execuções sem modificações acabaram sendo melhores do que com RTK. Aqui é a mesma coisa. Então, sim, é bem surpreendente, mas está ficando consistente, por assim dizer. O unlazy escreveu a lista de verificação antes de tocar no código, mas depois o Claude a aprovou sem me perguntar. Eu é que deveria aprovar essas verificações. E a verificação do comportamento solicitado simplesmente procurou palavras no código-fonte. Ela foi aprovada, mas o Astra descobriu que selecionar o script e apertar Delete não funcionava. A verificação da UI

08:42 ainda estava inacabada, e o Claude disse que não tinha testado o app. Eu não tinha instalado o hook Stop opcional, que deveria impedir que ele terminasse com verificações ainda pendentes. Também não experimentei o Depth Tree, que divide tarefas maiores em partes menores. Esta era uma pequena mudança na UI. Talvez eu aproveitasse mais a ferramenta em uma tarefa maior e com o hook instalado. Ainda não sei. Mas, de novo, nesta execução, adicionar unlazy ao Ponytail custou mais e deixou essa ação do teclado sem funcionar.

09:14 No vídeo passado, o RTK também usou mais tokens do que o Claude Code sem ele. Estou ficando um pouco relutante em instalar essas coisas sem verificar o que elas realmente fazem por mim. Vou experimentar outro repo em alta no GitHub para o próximo Purr Request. Se você estiver construindo algo que gostaria que eu testasse, deixe um link nos comentários ou no nosso Discord. O link do Discord está na descrição e, se isso foi útil, deixe um like. A minha gata não precisa de unlazy, aliás. Ela ficou miando para mim o tempo todo, e eu preferia que voltasse a dormir.

Transcrição original

[00:00] I tried unlazy on a small UI change and Claude Code did better without it. It used fewer tokens and built more of what I asked for. unlazy is a skill for Claude Code and Codex with about three and half thousand stars on GitHub. It’s supposed to stop the agent from leaving work unfinished. Before coding, the agent writes a checklist in GATES.md with a way to check each item. Then it’s supposed to keep working until those checks pass. I’m trying a new format called Purr Request,

[00:30] where I grab a GitHub repo and give it a go. For this one, I followed the quick start and added slash unlazy to my request. I hadn’t read through all the docs. I gave Opus 5.5 the same prompt in two worktrees with unlazy installed in one. Both had Ponytail Ultra running too, so we’re testing what unlazy adds to that setup. I’ll show you the bug it missed and why its check passed anyway.

[01:02] Okay, so this time we’re gonna be trying the unlazy skill. I think I’ve seen this skill for a while on some YouTube channels, but I haven’t really chance to try it. I’ve been trying to comprehend this documentation, but apparently it has been written with Opus 5, and Opus 5 isn’t the best model to write documentation, it’s like full of gates. Can you explain me what this skill does in plain human language?

[01:32] Okay, still a wall of text, but maybe just a little bit smaller wall of text. unlazy is a set of instructions plus a small checker script. It stops AI coding agent from saying done before the work is actually done. Yeah, sounds the exactly right thing to have. I mean, it probably doesn’t really align with the existing SDD workflow, but if you just prompt stuff, it seems to be always better to run this prompt with unlazy.

[02:03] But again, we need to find out if that’s really true and how much time it takes compared to the vanilla run. So, I guess what I’m gonna do now is to install this thing, and in Orca, I actually created two new worktrees. I’m gonna paste this command and install this thingy. Alright, the default seems to be fine, so I guess I can just run

[02:34] Claude Code again and have unlazy here. Okay, cool. So, what I actually want to try to do if I run The Gray Cut here, I don’t really like the way this UI looks like. I’d like to improve the homepage in this app. I don’t like that I cannot delete files once I add them. The only way to delete a file is actually to restart the app and drag them over.

[03:05] I want them to be deletable. When I select them and hit delete, they should just disappear. And maybe there should be like an X button on the right. And overall, I think the layout is not very friendly and welcoming, so if you can come up with something that makes it more usable, that would be much, much better. So, yeah. This prompt. And in this tab, I want to give it exactly the same prompt. Oh, yeah.

[03:36] By the way, I’m using Ponytail here, so it shouldn’t affect much, I think. Just mostly code styles and verbosity, but I’m not gonna remove it, right? I guess I’m gonna just babysit it here, answer any questions to unblock its progress. I’m not gonna use any plan mode or any other framework, I’ll just see how it goes. Checking what’s going on here, it seems the unlazy thing, the unlazy worktree,

[04:06] it went straight to writing the code. Same here. But, oh, we’ve got something. I did it. It builds. The without. It’s done in two minutes. So, what’s new on the home screen? Deleting files work now. Click a file, then press delete. It goes away. Yeah, that’s actually just a little better. Yeah, that’s definitely better.

[04:36] I pretty much like it, and it took two minutes without planning. It’s Opus 5.5, by the way. I haven’t really worked with this model, but, like, two minutes, and it made such visible improvements. Delete. This works. And this tiny thing works. Yeah, that’s exactly what I wanted it to build. And this thing also is done. I made the home screen change. The build passes. I did not click

[05:06] through myself. Oh, this is actually a little bit worse. I like the run button here. I guess the idea is basically the same. The icon is orange here, and the icon alignment is a little bit broken. Other than that, it seems to work. Like, this works, this works, this deletes. I guess now I need to run a dedicated Astra instance and check the implementation quality and the output.

[05:37] So, I have Astra high here. Go ahead. So, yeah. Let me take a break here. Okay, cool. So, Astra was clicking around and eventually came up with the verdict. And according to this verdict, surprisingly, unlazy-without wins this trial. And looking at the table, with unlazy it took 30 seconds more to execute. A little bit more tokens. 19%.

[06:09] These are nerdy stuff. Cache reads. More cache reads. More everything. Yeah, obviously, it was running more because it has more of everything, including the API equivalent cost. We almost spent a dollar with unlazy, but only 80 cents without unlazy. Yeah, looking at this, I think it actually complained about something. So, both: build passes, selecting take and pressing delete works.

[06:40] Without: selecting a script and pressing delete also works. The take X removal works. Oh, I didn’t actually think about testing the script removal. Maybe I need to use this Astra for testing stuff in the future. It finds some unexpected things. unlazy produced three passing gates and one unfinished UI gate. Oh, we are producing gates again. Astra, shame on you.

[07:10] It made incomplete verification visible, but did not prevent the run from stopping incomplete. Both implementations also leave saved project references unchanged when removing files after a failed or cancelled run. So, reopening restores those files. Interesting. It’s not about Ponytail, it’s about the new model and constantly evolving harness. And these tools seem to be built for previous versions of Claude Code,

[07:40] such as Opus 5, my favorite, and below. And now this new thing came out and it doesn’t work anymore. So, you always have to keep in mind that there’s always the rule that less is more. So, maybe now less tools is actually more. It depends, it definitely depends. But there’s a big chance that the old tools don’t work within new models. So, don’t hurry and install everything. Just like RTK, right?

[08:11] Now, the vanilla runs turned out to be better than RTK. Here it’s the same thing. So, yeah, pretty much surprising, but it’s getting consistent, so to speak. So, unlazy wrote the checklist before touching the code, but then Claude approved it without asking me. I was supposed to approve those checks. And the check for the requested behavior just searched for words in the source. It passed, but Astra found that selecting the script and pressing delete didn’t work. The UI

[08:42] check was still unfinished, and Claude did say it hadn’t tested the app. I hadn’t installed the optional Stop hook, which is supposed to stop it from finishing with checks still open. I also didn’t try Depth Tree, which splits bigger tasks into smaller pieces. This was a small UI change. Maybe I’d get more out of it on a bigger task and with the hook installed. I don’t know yet. But again, in this run, adding unlazy to Ponytail cost more and left that keyboard action broken.

[09:14] Last video, RTK used also more tokens than Claude Code without it. I’m getting a bit reluctant to install these things without checking what they actually do for me. I’ll try another trending GitHub repo for the next Purr Request. If you’re building something you’d like me to try, drop a link in the comments or in our Discord. The Discord link is in the description, and if this was useful, hit like. My cat doesn’t need unlazy, by the way. She’s been meowing at me the whole time, and I’d quite like her to go back to sleep.