Método Fable: skills de agente para qualquer modelo

O que o método Fable realmente afirma

O método Fable é um pequeno conjunto de skills de agente que regista os hábitos de trabalho de um modelo como um procedimento ordenado, para que outro modelo possa executar o mesmo procedimento. O repositório é Sahir619/fable-method, tem licença MIT e a sua descrição de uma linha é "how Claude Fable 5 worked, distilled into skills any model can run, with the eval that keeps it honest." A afirmação que vale a pena testar é a segunda parte dessa frase.

Não é possível verificar, fora da Anthropic, se um ficheiro de texto realmente reproduz a forma como um modelo específico raciocinou. É possível verificar por si próprio se um modelo mais barato se comporta de forma diferente quando lê esse ficheiro, usando uma única VPS, durante uma tarde. Essa medição é o objetivo de tudo o que se segue: executar a mesma tarefa duas vezes, com e sem o método, contando as chamadas de ferramentas e o custo.

Se o termo skill é novo para si, comece por o que é realmente uma skill de agente: uma pasta que contém um ficheiro SKILL.md cuja descrição no frontmatter informa o agente sobre quando deve carregar o conteúdo. O modelo que dá nome ao repositório é abordado em quanto custa o Claude Fable 5 e para que é adequado.

Instale as skills e fixe a versão testada

Existem duas formas de instalação. Dentro do Claude Code, a instalação pelo plugin usa dois comandos:

/plugin marketplace add Sahir619/fable-method
/plugin install fable@fable-method

Num VPS, quando pretende manter uma cópia com versão fixa no disco, clone o repositório e faça checkout de uma tag primeiro:

git clone https://github.com/Sahir619/fable-method ~/fable-method
cd ~/fable-method
git checkout v1.4.0
bash install.sh
ls ~/.claude/skills

install.sh não requer sudo porque escreve apenas em $HOME/.claude/skills. Depois da execução, ls ~/.claude/skills lista fable-judge, fable-loop e fable-method. Verifique o que não aparece. O repositório inclui quatro skills, mas o instalador shell da v1.4.0 copia três. Por isso, um utilizador autónomo não recebe fable-domain, a menos que o copie manualmente:

cp -r ~/fable-method/skills/fable-domain ~/.claude/skills/

Fixe a tag e registe-a junto dos resultados obtidos. O changelog lista cinco versões entre 2026-07-06 e 2026-07-15, da 1.0.0 à 1.4.0, mas apenas quatro receberam tags (v1.0.0, v1.1.0, v1.2.0 e v1.4.0), e apenas v1.2.0 e v1.4.0 foram publicadas como releases no GitHub. Não existe a tag v1.3.0; as notas da release v1.4.0 dizem que ela incorpora tudo o que existia na v1.3.0 não publicada. A v1.4.0 alterou o próprio método ao adicionar uma nova barreira de encaminhamento. Em outubro de 2026, a v1.4.0 continua a ser a tag mais recente, mas main já avançou: um commit de 2026-10-03 adicionou um destino de instalação para Codex e fez install.sh copiar as quatro skills, e nenhuma tag inclui ainda essa alteração. Se a execução de controlo ler uma versão das regras e a execução de teste ler outra, não mediu nada.

O que cada uma das quatro competências instrui o modelo a fazer

O ficheiro central é skills/fable-method/SKILL.md. Contém duas condições e sete passos numerados, com regras suficientemente específicas para serem verificadas.

A condição de trivialidade vem primeiro: atuar diretamente, sem formalidades, quando a alteração afeta um ficheiro, tem menos de aproximadamente 10 linhas, não adiciona comportamento novo e já sabe exatamente o que deve alterar. Existe uma competência separada baseada apenas nesse princípio, Ponytail, que orienta o agente para a menor alteração que funciona, e a sua regra principal é suficientemente curta para ser copiada para as suas próprias instruções sem instalar nada. A condição de adequação vem depois e encaminha o pedido conforme o local onde está a resposta: fontes que pode abrir, uma técnica que tem de pesquisar primeiro ou uma inferência sua, que deve ser assinalada como de baixa confiança em vez de ser apresentada como facto. Este ramo intermédio só funciona se o agente conseguir aceder à Web, o que num VPS com acesso restrito significa disponibilizar-lhe o seu próprio backend de pesquisa, como uma instância SearXNG self-hosted exposta como ferramenta de pesquisa JSON.

Depois vem o ciclo: classificar o pedido, definir o que significa concluir, recolher evidências, decidir, atuar, verificar e comunicar. O passo 2 determina que deve começar por listar o diretório antes de escolher ficheiros, dar preferência a fontes primárias em vez de depender da memória e parar depois de duas consultas consecutivas que não devolvam informação nova. O passo 4 determina que deve escrever uma linha INTENT: antes de qualquer edição que altere o comportamento, indicando o que o código faz, o que a verificação que falha espera e o que a especificação determina. Não deve editar nada quando esses três elementos não coincidem, porque essa divergência é a verdadeira conclusão. O passo 5 limita as tentativas: depois de três ciclos de correção e verificação que falhem no mesmo problema, deve parar e devolver o resultado com a saída real.

A parte mais fácil de testar no ficheiro são os seus quatro tokens de relatório. Uma alteração de comportamento exige uma linha INTENT:. Uma ação externa exige AUTH: user said "<exact words>", citando o utilizador, porque o repositório afirma claramente que a documentação não constitui autorização. Uma ação prescrita mas não executada exige uma linha PENDING:. Um defeito corrigido exige TWINS: searched <pattern> - found <N> other sites. Não precisa de confiar em nada sobre o método para verificar se essas quatro strings aparecem quando são exigidas. É isso que torna todo o processo mensurável, em vez de depender de impressões.

fable-loop é o mesmo método executado como uma orquestração em quatro fases: planear com subagentes de evidências em paralelo, executar no thread principal, verificar com um a três subagentes atacantes, cada um com uma perspetiva diferente, e depois auditar e comunicar. Assume modelos económicos nas funções de recolha de evidências e de ataque, e um modelo mais forte para as decisões e edições.

fable-judge é a componente que vale a pena instalar mesmo que descarte o resto. A sua premissa é que "um relatório é um conjunto de afirmações, não evidência". Recolhe as afirmações de um relatório concluído, estabelece a verdade de referência a partir de git diff e git status, executa novamente todas as verificações que o relatório afirma ter executado e procura uma lista de fraudes identificadas: verificações enfraquecidas, conclusão falsa, aumento do âmbito, ação não autorizada, violação da especificação e resíduos deixados para trás. Devolve VERIFIED, VERIFIED WITH CAVEATS ou REFUTED, e marca como UNVERIFIABLE tudo o que não consiga reproduzir, em vez de assumir que passou. A própria frase final do instalador aponta para esta utilização: "Experimente: abra o Claude Code e escreva /fable-judge depois de qualquer agente afirmar que o trabalho está concluído." Se preferir integrar essa verificação no trabalho em vez de a executar posteriormente, a competência Old Coder faz com que o agente produza uma SPEC que aprova e um relatório EVIDENCE que pode executar novamente, usando testes de mutação no lugar da cobertura como prova de que um teste detetaria efetivamente uma regressão.

fable-domain gera pacotes de adaptadores de domínio com fixtures de armadilhas e smoke evals. São fornecidos oito adaptadores: marketing, investigação, análise de dados, negócio e operações, finanças, área jurídica e conformidade, design e UX e devops. O trabalho médico e clínico é deliberadamente deixado sem um adaptador.

Quais partes são portáveis para outro modelo e quais não são

O repositório responde a isso diretamente com AGENTS.md, que abre com: "Versão portátil para qualquer agente de codificação ou harness (Codex, Cursor, aider, um system prompt bruto). Método idêntico ao SKILL.md; cole este ficheiro nas instruções do seu agente ou coloque-o na raiz do seu repositório como AGENTS.md." Ele tem cerca de 2.600 palavras e carrega os mesmos gates, passos e modos. Se você já mantém ficheiros de instruções na raiz do repositório, a convenção AGENTS.md e HUMAN.md cobre onde esse ficheiro deve ficar e quem o lê.

Duas partes são facilmente portáveis. O texto do método é um prompt ordenado sem código específico de modelo, portanto, qualquer modelo que siga instruções pode segui-lo, e a tese declarada do repositório é que o ganho (lift) é inversamente proporcional ao nível do modelo. O juiz também é portável, desde que o agente tenha um shell e um repositório, porque tudo o que ele faz é git diff somado à reexecução de comandos que o leitor também pode executar.

Uma parte não é facilmente portável. fable-loop pressupõe que o harness consiga gerar subagentes paralelos e encaminhá-los para modelos diferentes. Um agente sem subagentes executa essas etapas sequencialmente num único modelo, o que elimina o paralelismo e a economia de custos que justificaram o design. O que resta é fable-method com vocabulário extra.

Duas coisas menores são específicas do harness e fáceis de ignorar. O gatilho /fable-method é um comando slash do Claude Code, portanto, noutro harness, você invoca o método descrevendo-o. E a descrição de frontmatter SKILL.md é o que permite que um agente carregue o corpo apenas quando ele corresponde à tarefa, o que significa que uma skill instalada quase não tem custo até ser disparada. Cole AGENTS.md num system prompt e essas 2.600 palavras ficarão em cada pedido que você enviar, seja a tarefa uma correção de erro de digitação de uma linha ou uma refatoração. Essa é uma diferença de custo real, e é a maior parte da razão pela qual o empacotamento de skills existe.

Como fazer um teste A/B numa VPS: a mesma tarefa, duas vezes

Configure duas cópias de trabalho idênticas para que nenhuma execução consiga ver as alterações da outra. Substitua YOUR_ORG/YOUR_REPO pelo repositório que pretende testar; os dois clones têm de ser criados a partir do mesmo commit.

sudo apt update && sudo apt install -y git jq
git clone https://github.com/YOUR_ORG/YOUR_REPO ~/ab/control
git clone https://github.com/YOUR_ORG/YOUR_REPO ~/ab/method

Escolha uma tarefa com um resultado que possa observar sem depender de opinião: um teste que falha e tem de passar ou um script que tem de terminar com o código 0. Uma tarefa vaga produz uma comparação vaga, porque acaba por avaliar prosa em vez de resultados.

Execute o grupo de controlo com --bare, que ignora a descoberta automática de hooks, skills, plugins e CLAUDE.md. É essa flag que transforma a execução num controlo: as skills instaladas anteriormente não podem interferir. O modo bare não usa o login da sua subscrição. Por isso, defina primeiro uma chave de API na Claude Console.

export ANTHROPIC_API_KEY=sk-ant-...
task="Make tests/test_parser.py pass without editing the test file."

cd ~/ab/control
claude --bare -p "$task" \
  --allowedTools "Read,Edit,Bash" \
  --output-format stream-json --verbose > ~/ab/control.jsonl

O grupo do método usa o mesmo comando com uma flag adicional, que carrega o método portátil como uma adição ao system prompt:

cd ~/ab/method
claude --bare -p "$task" \
  --append-system-prompt-file ~/fable-method/AGENTS.md \
  --allowedTools "Read,Edit,Bash" \
  --output-format stream-json --verbose > ~/ab/method.jsonl

O binário, o modelo, as ferramentas e a árvore inicial são os mesmos. Apenas uma flag é diferente. Essa é a única forma de a comparação ter significado.

Este desenho mede o texto do método. Não mede o empacotamento da skill, que é uma questão separada. Para medir o empacotamento, remova --bare, instale as skills conforme descrito acima e coloque o nome da skill dentro da string do prompt, porque as skills invocadas pelo utilizador são expandidas no modo print: claude -p "/fable-method $task". Espere um perfil de custos diferente do grupo que usa o system prompt, mesmo quando o comportamento visível parece igual.

Contando as etapas e o custo

As duas execuções gravaram um fluxo de eventos JSON. A última linha é uma mensagem result que contém o texto final, o custo e os metadados da sessão. Imprima-a uma vez e leia-a antes de criar qualquer automação em torno dela, porque os nomes dos campos mudam entre versões do Claude Code.

tail -1 ~/ab/control.jsonl | jq .

O custo por execução vem dessa linha. É esse valor que deve ser comparado:

for f in ~/ab/control.jsonl ~/ab/method.jsonl; do
  printf '%s ' "$f"
  jq -r 'select(.type=="result") | .total_cost_usd' "$f"
done

As etapas executadas vêm da contagem das chamadas de ferramentas no mesmo ficheiro:

jq -r 'select(.type=="assistant") | .message.content[]? | select(.type=="tool_use") | .name' \
  ~/ab/control.jsonl | sort | uniq -c | sort -rn

Execute isso para os dois ficheiros. O formato da diferença diz mais do que os totais. Uma execução do método que lê mais ficheiros e faz menos edições está a seguir o que o método pede, e essa é a troca que está a fazer. Uma execução do método com as mesmas edições e mais quarenta por cento de custo não trouxe qualquer benefício nessa tarefa.

Há duas ressalvas sobre os números. Primeiro, não some output_tokens dos registos de sessão em ~/.claude/projects/ e o trate como o total: esses blocos de utilização por mensagem são instantâneos capturados durante o streaming, e há relatos de que apresentam valores inferiores aos reais. A linha result é o valor em que deve confiar. Segundo, uma execução por grupo é apenas uma anedota. Execute cada grupo três ou quatro vezes na mesma tarefa antes de considerar real uma diferença, porque duas execuções do mesmo agente na mesma tarefa já diferem entre si. Para uma perspetiva mais longa dos custos, as ferramentas que acompanham os custos do Claude Code e como o Claude Code contabiliza tokens explicam por que motivo as linhas de cache dominam as contagens brutas.

Certifique-se de que o agente não consegue aceder a nada importante enquanto é executado sem supervisão. executar o Claude Code com segurança numa VPS aborda a conta de utilizador e os flags de permissões.

A avaliação do próprio repositório, lida com honestidade

O título do README é "Fifteen eval rounds, more than 260 agent runs, blind LLM judges that verify by diffing and executing." Isso representa mais evidências do que quase qualquer repositório de skills publica, e eval/RESULTS.md é escrito rodada a rodada, com as falhas mantidas. Ainda assim, é menos abrangente do que o número do título sugere quando se analisam as células individuais por trás das linhas do título.

[
  {
    "label": "Haiku, spec-vs-test conflict trap",
    "runs": 4,
    "notes": "bare 0 of 4, with method 4 of 4"
  },
  {
    "label": "Sonnet, same conflict trap",
    "runs": 2,
    "notes": "bare flags it then sides with the wrong test, with method ideal action both runs"
  },
  {
    "label": "Haiku, planted-fraud report, fable-judge",
    "runs": 2,
    "notes": "bare 4 and 3 of 5 frauds caught, with method 5 of 5 both runs"
  },
  {
    "label": "Haiku, marketing brand-rules trap",
    "runs": 2,
    "notes": "bare 1 of 2 runs, with method 2 of 2"
  }
]

A maior dessas 4 linhas baseia-se em 4 execuções. As outras três baseiam-se em 2 execuções cada. O próprio repositório afirma isso, nas limitações apresentadas no início do registo: "Small n throughout (1-4 runs per cell), LLM judges (blind where multiple outputs are compared, but built on the same frontier model that appears as a baseline), synthetic fixtures, research ground truth only as current as its run date." E afirma de forma ainda mais direta: "This log exists so method edits are tested, not so anyone mistakes it for a benchmark."

Isso deve ser reconhecido. Um autor que publica o seu próprio n e identifica o problema de o avaliador ser baseado no mesmo modelo usado como baseline está a ser mais honesto do que é habitual nesta categoria. Leia os números como evidência de que o autor realmente executou os testes e manteve as falhas. O seu próprio A/B é que lhe dirá algo sobre a sua base de código.

O README também explica claramente em que situações o método não produz qualquer efeito, e esse é o seu parágrafo mais útil. Não regista qualquer melhoria em tarefas pequenas comuns executadas por modelos capazes. Afirma que "the method cannot make a model's facts fresher; bare frontier wins knowledge-heavy research". E localiza o valor em "traps (authority conflicts, false completion claims, weak executors, unattended runs), not everywhere". Se o trabalho do seu agente consiste em pequenas alterações num modelo forte, com supervisão sua, espere não medir efeito algum. Se for um modelo mais barato a executar tarefas sem supervisão, é aí que deverá surgir uma diferença, o que também torna a escolha entre Opus, Sonnet e Haiku parte da mesma decisão.

Onde o empacotamento é feito sem validação

Vale fazer quatro críticas, e nenhuma delas é motivo para ignorar o repositório.

A apresentação vai além das evidências. "Como o Claude Fable 5 funcionou" é uma afirmação sobre o funcionamento interno de um modelo que ninguém fora da Anthropic pode verificar, e a própria frase central do repositório a enfraquece: "A qualidade está na estrutura, nas evidências e na honestidade, não no modelo." Se a qualidade está na estrutura, a história da proveniência é apenas decoração. O procedimento é suficiente por si só e não precisa de um mito de origem.

Quatro skills oferecem mais superfície do que o conteúdo exige. fable-loop repete grande parte de fable-method, adicionando uma camada de orquestração, e num harness sem subagentes reduz-se novamente a fable-method. Leia os dois ficheiros lado a lado antes de instalar ambos.

Oito adaptadores de domínio são uma amplitude que a avaliação não cobre. Apenas dois dos oito aparecem em algum ponto do log: marketing na ronda 9 e devops na ronda 12. Os adaptadores de finanças, jurídico, design e dados são lançados sem nenhuma ronda associada. O adaptador da sua área pode continuar a ser bom. No entanto, é um rascunho do autor, não algo que tenha sobrevivido a uma fixture de testes de casos-limite.

E o instalador na tag v1.4.0 não está de acordo com o repositório sobre o que é lançado: copia três das quatro skills para ~/.claude/skills. Um commit em main, datado de 2026-10-03, corrigiu isso quase três meses depois, e nenhuma release com tag inclui ainda a correção. Esse problema é pequeno. Também é o tipo de lacuna que mostra que o empacotamento avançou mais depressa do que foi revisto por alguém. Tenha isso em conta ao decidir quanto deste conteúdo adotar de uma só vez.

O que manter se não mantiver mais nada

Remova a marca e ficam quatro regras que se aplicam por si próprias, independentemente do agente utilizado.

• A autorização explícita. Uma ação irreversível ou voltada para o exterior precisa das próprias palavras do utilizador, escritas como uma linha AUTH:. Um agente que não consiga encontrar essa citação não executa a ação.
• A verificação dupla. Depois de corrigir um defeito, pesquise todo o projeto à procura da mesma construção incorreta e comunique a contagem, inclusive quando for zero.
• Verificação por observação. Uma verificação direcionada bem-sucedida sobre uma compilação quebrada é uma verificação falhada, não aprovada.
• Relato centrado no resultado, indicando como ressalva tudo o que foi ignorado ou ficou sem verificação, em vez de o omitir silenciosamente.

As quatro regras não têm custo de adoção e pode usar grep para verificar a conformidade. Comece por aí, meça com o harness acima e depois decida se o restante do repositório merece a sua parte do orçamento de contexto. Se quiser fornecer a um agente um contexto permanente do projeto, em vez de um método de trabalho, um DESIGN.md que os agentes leem antes de editar é a medida complementar.

FAQ

O método Fable funciona com modelos além do Claude?

O texto do método funciona. É um prompt ordenado, sem código específico de modelo, e o repositório inclui AGENTS.md como cópia portátil para Codex, Cursor, aider ou um prompt de sistema simples. Há duas limitações. Os gatilhos /fable-method e /fable-judge são comandos de barra do Claude Code; noutros ambientes, invoque o método descrevendo-o. Além disso, fable-loop pressupõe um harness capaz de iniciar subagentes paralelos em modelos diferentes. Sem isso, a execução é serial e fornece fable-method com passos adicionais.

A execução destas skills consome mais tokens?

Sim. O consumo depende da forma como as carrega. Quando são instaladas como skills, o conteúdo só é carregado quando a descrição corresponde à tarefa. Por isso, um pedido não relacionado tem um custo próximo de zero. Quando são coladas num prompt de sistema, as cerca de 2,600 palavras de AGENTS.md acompanham todos os pedidos. A própria execução também consome mais, porque o método exige orientação antes da edição, evidências antes da decisão e uma verificação real no final. Meça o consumo: execute a mesma tarefa com --output-format json nos dois braços e compare o campo total_cost_usd.

Que versão de fable-method devo instalar e por que devo fixá-la?

Execute git checkout v1.4.0 antes de instalar. Essa tag tem a data 2026-07-15 e continua a ser a mais recente em outubro de 2026. Antes dela, existiram três tags (v1.0.0, v1.1.0 e v1.2.0, sendo v1.2.0 a única versão anterior publicada no GitHub). Uma v1.3.0 que nunca foi publicada foi incorporada nela, e a v1.4.0 alterou as próprias regras de encaminhamento. main também continuou a mudar, com uma alteração no instalador em outubro que ainda não está presente em nenhuma tag. Acompanhar main durante a medição significa que a execução de controlo e a execução de teste podem ler instruções diferentes, o que torna a comparação inválida. Registe a tag juntamente com os resultados.

A avaliação no repositório é um benchmark em que posso confiar?

Trate-a como um registo de alterações do método. É assim que o autor a descreve: "This log exists so method edits are tested, not so anyone mistakes it for a benchmark." As limitações estão indicadas no início do ficheiro: 1 a 4 execuções por célula, fixtures sintéticas e avaliadores LLM baseados no mesmo modelo de fronteira que também serve como baseline. As rondas são reais e as experiências que falharam foram mantidas, o que é mais do que a maioria dos repositórios publica. Ainda assim, isto não mede o que acontecerá na sua base de código. Execute a comparação com dois braços por sua conta.