Wally Skills — Ciclo Completo de Desenvolvimento com Claude
eldelentes/wally-skills
Skills especializadas para cada fase do desenvolvimento, do conceito ao deploy
Ver no GitHubColeção de skills focadas que guiam todo o ciclo de vida de um projeto de software, desde pesquisa e planejamento até implementação e aprendizado. Cada skill é um agente opinado que executa uma fase específica (brainstorm, plan, build, learn) e encadeia naturalmente com as demais, promovendo fluxo de trabalho estruturado e outputs prontos para produção.
Instalação
npx convez-ai eldelentes/wally-skills1 comando no terminal: detecta o formato do repositório (marketplace ou plugin avulso) e instala via Claude Code. Requer Node 18+ e o Claude Code instalado.
Métricas
Casos de uso
- Pesquisar e comparar tecnologias antes de comprometer-se com uma solução
- Transformar ideias vagas em planos estruturados e checáveis
- Executar implementações com instruções explícitas e livres de ambiguidade
- Bootstrapear novos projetos com scaffold automático e README customizado
Veredito

Conjunto bem pensado que institucionaliza boas práticas de desenvolvimento (pesquisa → planejamento → execução) via skills encadeadas. Ideal para times que querem fluxos reproduzíveis e código sem ambiguidades, mas exige disciplina para usar em sequência correta.
README
A tradução para o português deste README ainda está na fila.
wally-skills
A collection of Claude Code skills that cover the full lifecycle of a software project — from ideation and research to implementation and learning from experience.
Each skill is a focused, opinionated agent that handles one phase of the development workflow. They're designed to chain together naturally: setup → brainstorm → plan → build → learn.
Skills
/wally-brainstorm
Research and explore implementation options before committing to building something.
Arrives at a structured research document saved to .claude/research/[feature-name].md with concrete options, tradeoffs, and a recommendation.
When to use:
- You know what you want to build but not how
- You want to compare technologies, libraries, or APIs
- You're in discovery mode and need to see the landscape
Trigger phrases: "what options do I have", "how should I build X", "compare X vs Y", "qué tecnología", "qué API"
What it does:
- Sharpens the problem with focused questions (5 Whys)
- Runs 5–8 parallel web searches across GitHub, Reddit, HN, official docs, and dev blogs
- Presents 3–5 options with strengths, tradeoffs, cost, and effort
- Gives an honest recommendation based on your constraints
- Saves the full research to
.claude/research/[feature].md
Example:
/wally-brainstorm I want to add real-time notifications to my Next.js app
Output: a comparison of WebSockets, SSE, Pusher, Ably, and Supabase Realtime — with a recommendation based on your scale and stack.
/wally-plan
Turn a vague feature idea into a clear, actionable task list before any code gets written.
Arrives at a structured plan saved to .claude/plan/[feature-name].md with explicit decisions, tasks, and assumptions — ready to hand off to /wally-build.
Designed for a plan-expensive, build-cheap workflow: run this skill on a high-effort model, then let a cheaper model implement. Because of that, the plan is written for a weaker executor — exact file paths, function signatures, patterns to copy, gotchas spelled out, and a mechanically checkable "done when" per task — so the implementer never has to infer.
When to use:
- You've done the research (or already know what you want) and need to scope it into tasks
- You want to lock in architectural decisions before touching code
- Right after
/wally-brainstormwhen you have options and need to pick a path
Trigger phrases: "help me plan", "break this down", "what tasks do I need", "scope this out", "haz un plan", "ayúdame a planear"
What it does:
- Checks
.claude/research/[feature-name].mdfor prior research and uses it as a starting point - Asks recursive A/B/C questions for every fuzzy area — always with a recommendation, never open-ended
- Uses ASCII diagrams for architecture decisions and ASCII mockups for UI layout decisions
- Presents the full plan for your approval before saving anything
- Saves the approved plan to
.claude/plan/[feature-name].md
Example:
/wally-plan add real-time notifications
Output: decisions locked (polling vs webhooks, where state lives, auth scope), assumptions listed, and a numbered task list the builder can execute without asking questions.
/wally-setup
Bootstrap a new project from scratch: create the GitHub repo, scaffold the chosen stack, find relevant skills, and write a custom README.
When to use:
- Starting a new project from zero
- You want a real repo with proper scaffolding, not a local folder
Trigger phrases: "start a new project", "create a new repo", "scaffold X", "set up a new app", "crear un proyecto nuevo"
What it does:
- Gathers project name, stack, description, and visibility
- Runs preflight checks (
gh auth status,git) - Creates a private GitHub repo via
ghCLI and clones it - Scaffolds the stack using the canonical bootstrapper (e.g.
create-next-app,uv init) - Discovers and installs relevant skills from the skills.sh ecosystem
- Writes a custom README tailored to the actual scaffolded structure
- Commits and pushes everything
This skill has real side effects. It confirms with you before creating the repo or pushing.
Example:
/wally-setup project: task-tracker, stack: Next.js + Tailwind + Supabase, private
/wally-build
Execute a feature implementation end-to-end — branch, code, test, commit, push, PR.
When to use:
- You have a plan (from
/wally-brainstormor your own head) and want to ship it - You want the full loop: branch → code → verify → commit → PR
Trigger phrases: "build this", "implement", "ship it", "create the PR", "haz esta feature", "implementa"
What it does:
- Reads the plan from
.claude/plan/[feature-name].md(or works from a verbal description) - Creates a
feat/[name]branch offmain - Defines a testing strategy before writing any implementation
- Decomposes tasks into parallel (independent) and sequential (dependent) work
- Spawns parallel subagents for independent tasks to save time
- Runs lint, typecheck, and tests before committing
- Commits with conventional commit messages (
feat:,fix:,chore:, etc.) - Pushes and opens a PR via
gh pr createwith a structured description
Confirms with you before pushing or opening the PR. Never auto-merges.
Example:
/wally-build implement the auth flow from the plan
/wally-learn
Extract durable patterns from the current conversation and propose new entries for your Claude memory.
When to use:
- At the end of a productive session where you corrected Claude or established conventions
- When you want Claude to remember something for all future conversations
- When you notice Claude making the same mistake repeatedly
Trigger phrases: "save what we learned", "update my memory", "remember this for next time", "aprende de esto", "guarda esto"
What it does:
- Scans the conversation for patterns worth capturing: repeated corrections, stated preferences, architectural decisions, gotchas
- Categorizes them by memory type: user, feedback, project, reference
- Presents proposed memories for your approval — you can accept, edit, or reject each one
- Writes only what you explicitly approve — one fact per memory file, plus a pointer in
MEMORY.md - Shows you which files changed so you can verify it landed correctly
Never writes to memory without explicit confirmation. Silent writes are an anti-pattern.
Example:
/wally-learn
After a session where you corrected Claude to use Vitest instead of Jest, avoid Redux, and always use kebab-case for file names — it surfaces those three as candidates and asks which to keep.
How they chain together
/wally-setup → repo created, stack scaffolded (new projects only)
/wally-brainstorm → research saved to .claude/research/
/wally-plan → decisions locked, tasks saved to .claude/plan/
/wally-build → feature branch, code, PR
/wally-learn → patterns saved to memory (MEMORY.md index)
You don't have to use all of them — each skill works standalone. But they're designed so the output of one becomes the input of the next. setup is the entry point for a brand-new project; on an existing codebase you'll usually start at brainstorm or plan. brainstorm, plan, and learn auto-trigger from natural language, while setup and build require explicit invocation because they have real side effects (new repos, pushed branches, PRs).
Installation
npx skills add https://github.com/eldelentes/wally-skills --skill wally-setup
npx skills add https://github.com/eldelentes/wally-skills --skill wally-brainstorm
npx skills add https://github.com/eldelentes/wally-skills --skill wally-plan
npx skills add https://github.com/eldelentes/wally-skills --skill wally-build
npx skills add https://github.com/eldelentes/wally-skills --skill wally-learn
Or install all at once:
npx skills add https://github.com/eldelentes/wally-skills