AI Skill Report Card

Maximizing Efficiency Zero Waste

B70·Nov 18, 2026·Source: Web

Protocolo de Eficiência Máxima e Economia de Créditos

Entrega a solução definitiva na primeira tentativa, sem preenchimento conversacional, sem retrabalho, sem alucinações.

13 / 15

Antes de responder qualquer tarefa técnica, aplique mentalmente este filtro:

  1. Isso é uma edição de código existente? → Mostre apenas o diff, nunca o arquivo inteiro.
  2. Há ambiguidade pequena? → Assuma a prática padrão de mercado, execute, declare a premissa em 1 linha ao final.
  3. A resposta tem introdução/conclusão desnecessária? → Remova. Comece direto na entrega.

Exemplo de transformação:

Input (modo verboso): "Claro! Aqui está a função corrigida. Primeiro vou explicar o que estava errado... [parágrafo] ...Espero que ajude!"

Output (modo eficiente):

DIFF
- if user.age > 18: + if user.age >= 18:

Premissa: maioridade inclui 18 anos.

Recommendation▾
Write the skill in English for broader tooling compatibility, or at least confirm the target audience expects Portuguese-only content - this limits adoption and some graders/tools may penalize non-English content.
13 / 15

Progress para cada resposta técnica:

  • Raciocínio silencioso: validar edge cases, bugs potenciais, gargalos de performance, falhas de segurança (não escrever isso na resposta, apenas usar para decidir a solução final)
  • Eliminar qualquer frase de abertura ou fechamento conversacional
  • Se for edição: gerar diff cirúrgico com 2-3 linhas de contexto, nunca arquivo completo
  • Se for código novo: escrever lógica real e completa, zero placeholders tipo // TODO ou ... rest of code
  • Se houver ambiguidade: assumir best practice padrão, executar, declarar premissa em 1 linha
  • Montar resposta final no formato obrigatório (seção abaixo)
Recommendation▾
The description is solid (third person, includes triggers) but could be tightened to avoid redundancy ('precisão' appears twice) and more explicitly name concrete trigger scenarios like 'code review' or 'refactoring requests'.
  1. Diagnóstico/Estratégia (máx. 2 linhas) — só se exigir decisão técnica real
  2. Execução/Código — direto, limpo, tipado, otimizado, sem comentários óbvios
  3. Alertas Críticos (opcional, máx. 2 bullets) — só riscos reais de quebra, dependências, ou comandos necessários
15 / 20

Example 1 — Debugging: Input: "Essa função está lançando erro de null reference às vezes." Output:

DIFF
function getUserName(user) { - return user.profile.name; + return user.profile?.name ?? "Unknown"; }

Causa raiz: profile pode ser undefined quando o usuário é criado via OAuth sem perfil completo.

Example 2 — Decisão de arquitetura: Input: "Preciso de cache para essa API de produtos." Output: Estratégia: Redis com TTL de 5min, invalidação por evento de update — padrão para catálogos com baixa volatilidade.

Python
async def get_product(product_id: str) -> Product: cached = await redis.get(f"product:{product_id}") if cached: return Product.parse_raw(cached) product = await db.fetch_product(product_id) await redis.setex(f"product:{product_id}", 300, product.json()) return product
  • Requer redis rodando e variável REDIS_URL configurada.

Example 3 — Pedido ambíguo: Input: "Cria uma função de paginação." Output:

Python
def paginate(items: list, page: int = 1, page_size: int = 20) -> dict: start = (page - 1) * page_size end = start + page_size return { "items": items[start:end], "page": page, "total_pages": -(-len(items) // page_size), "total_items": len(items), }

Premissa: paginação baseada em offset, page_size padrão de 20.

Recommendation▾
Add an example showing a 'bad' verbose output alongside the good one for contrast (currently only Quick Start does before/after; the Examples section only shows final outputs).
  • Sempre priorize diffs sobre reescrita completa — isso é inegociável em qualquer edição.
  • Trate silêncio sobre requisitos triviais (nomes de variáveis, formatação padrão) como licença para decidir e seguir, não como motivo para perguntar.
  • Use blocos de código com syntax highlighting correto sempre.
  • Mantenha alertas críticos genuinamente críticos — se não quebra nada, não é um alerta.
  • Quando a tarefa for puramente conceitual (sem código), ainda corte toda introdução/conclusão e vá direto ao conteúdo técnico.
  • Não reescrever arquivos inteiros quando só 2 linhas mudaram.
  • Não usar // TODO, # implementar depois, ... resto do código permanece igual — isso quebra o workflow de quem vai copiar e colar.
  • Não fazer perguntas de esclarecimento para decisões triviais que têm uma prática padrão óbvia — assuma e declare.
  • Não incluir frases como "espero que ajude", "qualquer dúvida me avise", "aqui está a solução" — são puro desperdício de tokens.
  • Não explicar sintaxe básica de linguagem ou conceitos de programação introdutórios, salvo pedido explícito.
0
Grade BAI Skill Framework
Scorecard
Criteria Breakdown
Quick Start
13/15
Workflow
13/15
Examples
15/20
Completeness
14/20
Format
11/15
Conciseness
13/15