convez.ai
SkillProdutividadeIntermediário
eldelentes

Wally Skills — Ciclo Completo de Desenvolvimento com Claude

eldelentes/wally-skills

Skills especializadas para cada fase do desenvolvimento, do conceito ao deploy

Ver no GitHub
InicialPluginScore · de 0 a 100

Coleçã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-skills

1 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

Estrelas
1
Forks
0
Acompanhando
0
Saúde
28%
Último commit
há 2 meses
Versão
—
Issues abertas
0
Contribuidores
1

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:

  1. Sharpens the problem with focused questions (5 Whys)
  2. Runs 5–8 parallel web searches across GitHub, Reddit, HN, official docs, and dev blogs
  3. Presents 3–5 options with strengths, tradeoffs, cost, and effort
  4. Gives an honest recommendation based on your constraints
  5. 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-brainstorm when 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:

  1. Checks .claude/research/[feature-name].md for prior research and uses it as a starting point
  2. Asks recursive A/B/C questions for every fuzzy area — always with a recommendation, never open-ended
  3. Uses ASCII diagrams for architecture decisions and ASCII mockups for UI layout decisions
  4. Presents the full plan for your approval before saving anything
  5. 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:

  1. Gathers project name, stack, description, and visibility
  2. Runs preflight checks (gh auth status, git)
  3. Creates a private GitHub repo via gh CLI and clones it
  4. Scaffolds the stack using the canonical bootstrapper (e.g. create-next-app, uv init)
  5. Discovers and installs relevant skills from the skills.sh ecosystem
  6. Writes a custom README tailored to the actual scaffolded structure
  7. 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-brainstorm or 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:

  1. Reads the plan from .claude/plan/[feature-name].md (or works from a verbal description)
  2. Creates a feat/[name] branch off main
  3. Defines a testing strategy before writing any implementation
  4. Decomposes tasks into parallel (independent) and sequential (dependent) work
  5. Spawns parallel subagents for independent tasks to save time
  6. Runs lint, typecheck, and tests before committing
  7. Commits with conventional commit messages (feat:, fix:, chore:, etc.)
  8. Pushes and opens a PR via gh pr create with 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:

  1. Scans the conversation for patterns worth capturing: repeated corrections, stated preferences, architectural decisions, gotchas
  2. Categorizes them by memory type: user, feedback, project, reference
  3. Presents proposed memories for your approval — you can accept, edit, or reject each one
  4. Writes only what you explicitly approve — one fact per memory file, plus a pointer in MEMORY.md
  5. 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
Ver o original no GitHub

Bom para

Relacionados