Método SOCLE
Framework de criação de produto digital em 5 etapas sequenciais. Cada etapa produz entregáveis concretos que alimentam a próxima.
Princípio
Preparamos o terreno completo antes de construir a primeira funcionalidade visível. Cada decisão é tomada uma única vez, na ordem. As fundações técnicas são estabelecidas em uma única passada, inclusive para o que será construído depois. O desenvolvimento avança por incrementos curtos, cada um completo e implantado antes de passar ao próximo.
As 5 etapas
S — Estruturar as escolhas
Começamos pelas decisões que importam. Para quem nos dirigimos, qual problema resolvemos, quais tecnologias, como medimos. Uma de cada vez, na ordem, e cada uma abre a porta para a próxima.
Entregáveis desta etapa:
- Visão do produto em uma frase
- Público-alvo (persona primária e secundária)
- Problema resolvido (específico, mensurável)
- Stack técnica definida
- Direção visual escolhida
- Modelo de monetização identificado (mesmo que freemium, mesmo que para depois)
- Nome do produto
Como proceder:
- Fazer perguntas de enquadramento com opções fechadas (sem brainstorming aberto)
- Definir cada decisão antes de passar para a próxima
- Consolidar em uma tabela de decisões definidas
- Identificar concorrentes e diferenciais
Leia references/structurer-checklist.md para a lista completa de decisões a tomar.
O — Ferramentar o terreno
Preparamos todo o terreno em uma única passada. O banco de dados, as páginas, a autenticação, o monitoramento, as convenções. Tudo está pronto, inclusive para o que construiremos depois.
Entregáveis desta etapa:
- Estrutura de rotas definitiva (as URLs não mudarão mais)
- Esquema de banco de dados completo (todas as tabelas, mesmo as não usadas na V0.1)
- Design tokens CSS (variáveis, tipografia, cores, espaçamento)
- Variantes de animação (Framer Motion ou equivalente)
- Plano de tag analytics (eventos, funil de conversão)
- Pipeline CI/CD (lint, type-check, testes, build automático)
- Arquivo CLAUDE.md (instruções do projeto para Claude Code)
- Arquivo CURRENT_INCREMENT.md (escopo do primeiro incremento)
- Configuração de middleware (auth, redirecionamentos, cabeçalhos de segurança)
- Variáveis de ambiente documentadas
Como proceder:
- Gerar a estrutura de rotas completa (marketing, auth, app, admin, API)
- Escrever o esquema SQL completo com enums, indexes, RLS, triggers
- Configurar o design system (globals.css + tailwind.config.ts)
- Criar os arquivos de contexto do projeto (CLAUDE.md, ARCHITECTURE.md, etc.)
- Scaffold do projeto, instalar todas as dependências, primeiro commit, implantar
Leia references/outiller-templates.md para os templates de cada arquivo.
C — Construir por partes
Avançamos por incrementos curtos. Cada incremento resulta em algo completo, que pode ser mostrado, testado, usado. Um pedaço real de produto, que funciona do início ao fim.
Princípios:
- Cada incremento tem um escopo fechado escrito em CURRENT_INCREMENT.md
- Cada incremento tem critérios de done testáveis
- Cada incremento tem uma lista explícita do que está fora do escopo
- As tarefas são ordenadas: cada tarefa depende apenas das anteriores
- Cada tarefa segue o ciclo: codificar, testar, verificar, commitar
Estrutura de um incremento:
# V0.X — [Nome do incremento]
## Objetivo
[O que o usuário pode fazer ao final deste incremento]
## Tarefas (na ordem)
[Lista numerada de tarefas com detalhes]
## Critérios de done
[Lista de verificações concretas]
## Fora do escopo
[Lista explícita de tudo que NÃO está neste incremento]
Verificações sistemáticas após cada tarefa:
- O type-check passa
- Os testes passam
- Sem tipos
any - As props são tipadas
- As entradas da API são validadas
- O commit segue conventional commits
L — Entregar a cada etapa
Cada peça fica online e nas mãos de usuários reais antes de passar para a próxima. O feedback chega cedo, os ajustes também.
Princípios:
- Cada incremento é implantado em produção (ou preview) assim que concluído
- O deploy é automático (push na main = deploy Vercel)
- Erros de produção são detectados imediatamente (monitoramento, error boundaries)
- Os eventos de analytics estão ativos desde o primeiro incremento
- Só começamos o próximo incremento quando o anterior está estável
Checklist de entrega:
- Build passa no CI
- Zero erros no console em produção
- As páginas têm metadados (title, description)
- O responsivo funciona (verificar mobile)
- Os eventos de analytics estão sendo rastreados
- A URL está acessível e funcional
E — Expandir sem refazer
O produto cresce naturalmente. Novas funcionalidades se apoiam no que existe, o design evolui, as integrações se conectam. A estrutura permanece estável porque o terreno estava pronto desde o início.
Princípios:
- Novos incrementos nunca invalidam os anteriores
- As tabelas do banco já estão prontas (adicionadas na etapa O)
- As variáveis CSS permitem mudar o estilo sem tocar nos componentes
- As rotas são estáveis (as URLs não mudam)
- As convenções de código são as mesmas do primeiro ao último incremento
Ao adicionar um incremento:
- Atualizar CURRENT_INCREMENT.md com o novo escopo
- Verificar se as fundações (etapa O) cobrem as necessidades
- Se faltar uma tabela ou rota: adicionar por migração, não por reconstrução
- Codificar, testar, implantar seguindo as mesmas convenções da V0.1
Como aplicar SOCLE a um novo projeto
Sequência completa
1. ESTRUTURAR
│ Conversa de enquadramento (perguntas fechadas)
│ Tabela de decisões definidas
│ Visão, público-alvo, stack, monetização
↓
2. FERRAMENTAR
│ Gerar todos os arquivos de fundação
│ Rotas, BD, tokens, analytics, CI/CD
│ Scaffold, implantar, primeiro commit vazio
↓
3. CONSTRUIR (V0.1)
│ Primeiro incremento: o núcleo mínimo
│ Auth + uma funcionalidade core + um export
│ Testes, commit, implantar
↓
4. ENTREGAR (V0.1)
│ Em produção, testado por usuários reais
│ Analytics ativos, erros monitorados
│ Estável antes de passar para V0.2
↓
5. EXPANDIR (V0.2, V0.3, ...)
│ Cada incremento segue C → L
│ As fundações absorvem o crescimento
│ Sem reconstrução
Arquivos de projeto a gerar (etapa O)
| Arquivo | Função |
|---|---|
CLAUDE.md | Instruções Claude Code: convenções, fluxo de trabalho, verificações |
CURRENT_INCREMENT.md | Escopo do incremento atual, tarefas ordenadas, critérios de done |
ARCHITECTURE.md | Rotas definitivas, estrutura de arquivos, fluxo de dados |
DB_SCHEMA.sql | Esquema completo do banco de dados |
DESIGN_TOKENS.md | Variáveis CSS, config Tailwind, variantes de animação |
AGENT_PROMPTS.md | System prompts se o projeto usar agentes de IA |
ROADMAP.md | Visão geral de todos os incrementos planejados |
Auditoria de complexidade (entre S e O)
Antes de passar para a etapa O, fazer um inventário de todos os componentes do projeto e avaliar sua complexidade. Se o número de componentes com complexidade alta ultrapassar 5, dividir em mais incrementos. A regra: cada incremento contém no máximo 3 a 5 componentes novos.
| Componente | Complexidade | Incremento previsto |
|---|---|---|
| [nome] | Baixa / Média / Alta | V0.X |
Se o projeto se assemelhar a uma catedral (mais de 20 componentes, mais de 6 com complexidade alta), rever o escopo. Simplificar a V0.1 até que seja realizável em uma a duas semanas por uma pessoa.
Stack técnica recomendada
O método SOCLE funciona com qualquer stack. Segue a stack padrão se o usuário não tiver preferência:
| Camada | Tecnologia |
|---|---|
| Framework | Next.js 14+ (App Router) |
| Linguagem | TypeScript strict |
| Estilização | Tailwind CSS + shadcn/ui |
| Animações | Framer Motion |
| Estado | Zustand |
| Auth | Supabase Auth |
| Banco de dados | Supabase (PostgreSQL) |
| Validação | Zod |
| Testes | Vitest + Testing Library |
| CI/CD | GitHub Actions |
| Deploy | Vercel |
Se o usuário tiver uma stack diferente, adaptar os templates da etapa O conforme necessário. Os princípios SOCLE permanecem os mesmos independentemente da stack.
Tom e postura
Ao aplicar SOCLE com um usuário:
- Tom profissional, maduro, conversacional
- Frases claras e diretamente úteis
- Sem jargão técnico não explicado ao falar com não-desenvolvedores
- Sem postura de superioridade
- Sem construções retóricas ("não é X, é Y")
- Guiamos, transmitimos, avançamos juntos