WellForge
Da un'idea a un progetto pronto allo sviluppo, in pochi minuti.
WellForge è il generatore di nuovi progetti AI-assisted di WellD. Risponde ad un problema: avere una base di partenza per generare lo scaffold di progetti sui diversi stack che possiamo usare, orchestrati da un sistema AI multi-agente comune. WellForge verifica che il sistema multi-agente sia aggiornato, ti guida nella scelta dell'architettura, crea lo scaffold dello stack e connette tutti gli strumenti che servono al caso specifico. Poi passa il testimone a Superpowers e alle agent-skills di Addy Osmani per lo sviluppo vero e proprio.
Cos'è WellForge
Non è un framework che sostituisce gli altri: è un layer di orchestrazione. Mette insieme tre cose che, da sole, richiederebbero ore di setup manuale ogni volta che parte un progetto nuovo.
Sempre aggiornato
Prima di ogni progetto risolve via GitHub API l'ultima versione stabile di Superpowers e agent-skills, e la installa su conferma.
Architettura guidata
Un wizard fa brainstorming, raccomanda un preset adatto e registra la decisione come ADR. Niente scelte a caso.
Strumenti connessi
Per ogni tool dello stack: verifica la CLI, fa il login e provisioning su conferma. I segreti restano nel tuo .env.local.
Handoff allo sviluppo
Finito lo scaffold, passa il controllo al ciclo spec → plan → TDD → review → ship dentro il tuo coding agent.
Come funziona
WellForge è ibrido: uno strato CLI (forge.sh + scripts/) che funziona ovunque, anche senza coding agent, e una skill Claude (wellforge + comando /forge-new) per la parte di ragionamento. Le quattro fasi:
| Fase | Cosa succede | Chi la guida |
|---|---|---|
| 1. Update | Risolve e (su conferma) installa le ultime versioni stabili del sistema multi-agente | forge.sh check/update |
| 2. Architettura | Brainstorming guidato, raccomandazione di un preset + alternativa, ADR | skill wellforge / Superpowers |
| 3. Scaffold | Copia lo scaffold comune + il template del preset, sostituisce i segnaposto | forge.sh new |
| 4. Connessione | Check CLI → login → provisioning per ogni strumento dello stack | connect-tools.sh |
Prerequisiti
Lo strato CLI richiede solo strumenti molto comuni. Il resto è opzionale e dipende dallo stack che scegli — WellForge ti dice cosa manca quando serve.
| Necessario | Per cosa |
|---|---|
bash, curl | Eseguire la CLI e interrogare la GitHub API |
git | Versioning + modalità "vendor" delle skill |
claude (consigliato) | Usa i marketplace ufficiali per Superpowers e agent-skills (modalità "plugin") |
GITHUB_TOKEN (o esegui gh auth login) per evitare i limiti di rate della GitHub API durante il controllo versioni.Installazione & avvio
WellForge ha due strati: una skill/plugin (skill wellforge, orchestratore e comando /forge-new) e uno strato bash (forge.sh). Dentro un coding agent non ti serve un terminale: l'agente esegue gli script per te col suo strumento Bash. Ecco come installarlo e avviarlo nei quattro ambienti.
aramilgalanodel/welld-ai-marketplace è attualmente privato: per aggiungerlo serve accesso in lettura (login GitHub autorizzato sul repo). In Claude Desktop i plugin si aggiungono dalla GUI — Customize → Browse plugins — non con il comando /plugin, che è disponibile invece in CLI, VS Code/Cursor e JetBrains.1 · Claude Desktop
L'ambiente che usi tu. Nessun terminale necessario.
# A) come plugin — Customize → Browse plugins → aggiungi il marketplace # in CLI / IDE equivale a: /plugin marketplace add aramilgalanodel/welld-ai-marketplace /plugin install wellforge@welld # B) oppure "apri come cartella": apri la cartella wellforge come progetto # Avvio — scrivi in chat, in linguaggio naturale: "usa wellforge-orchestrator: costruiamo un nuovo servizio API"
forge.sh col suo Bash e ti riporta l'output: tu resti in chat.2 · VS Code o Cursor
Con l'estensione Claude Code nel pannello laterale.
/plugin marketplace add aramilgalanodel/welld-ai-marketplace /plugin install wellforge@welld /forge-new
3 · IDE JetBrains (IntelliJ, PyCharm, …)
Con il plugin Claude Code per JetBrains.
/plugin marketplace add aramilgalanodel/welld-ai-marketplace /plugin install wellforge@welld /forge-new
4 · CLI pura
Senza coding agent: lo strato bash funziona da solo.
cd wellforge ./forge.sh check # verifica versioni stabili ./forge.sh new # wizard completo ./forge.sh test # dry-run di tutti i preset
| Ambiente | Installazione | Avvio | Terminale richiesto? |
|---|---|---|---|
| Claude Desktop | Plugin o cartella | parli con l'AI | No |
| VS Code / Cursor | Plugin o cartella | /forge-new | No |
| JetBrains | Plugin o cartella | /forge-new | No |
| CLI pura | git clone / unzip | ./forge.sh new | Sì |
Orchestratore AI
Non devi sapere quale comando usare. La skill wellforge-orchestrator dialoga con te in linguaggio naturale, capisce l'intento e instrada al flusso giusto, delegando il lavoro pesante ai subagent — ma si ferma ai gate umani per le decisioni che contano.
Cosa è già automatico
Le skill si attivano da sole in base al contesto, e Superpowers dispatcha già subagent freschi per ogni task con review a due stadi. Dentro una fase, la delega ai worker non la fai tu.
Cosa instrada l'orchestratore
| Dici… | L'orchestratore instrada a… |
|---|---|
| "nuovo progetto / scaffold X" | skill wellforge → forge.sh new |
| "aggiungi / implementa feature Y" | /spec → /plan → sviluppo TDD |
| "è rotto / fallisce" | debugging sistematico |
| "connetti / deploy / CI" | connect-tools.sh, ci-cd, shipping |
| richiesta vaga | prima una domanda di chiarimento (interview/brainstorming) |
I gate umani (qui si ferma sempre)
Spec approvata
Dopo il brainstorming, prima di scrivere il piano.
Piano approvato
Dopo /plan, prima dell'implementazione.
Pre-deploy
Prima di deploy, migrazioni o azioni irreversibili.
"usa wellforge-orchestrator: aggiungi l'autenticazione al servizio"
Guida passo passo — parlando con l'AI
Una volta installato il plugin non scrivi comandi in un terminale: parli con l'AI in linguaggio naturale e lei esegue i passi per te — lancia gli script col suo strumento Bash, ti riporta gli output e si ferma a chiederti solo le decisioni che contano. Sotto, un giro tipico (👤 = quello che dici tu, 🤖 = cosa fa/risponde l'AI).
Avvia parlando con l'AI
Nel tab Code (o nel pannello Claude del tuo IDE) di' semplicemente cosa vuoi fare, oppure lancia il comando. Da qui guida l'AI.
👤 "Creiamo un nuovo progetto con WellForge" # equivalente esplicito: 👤 /forge-new
L'AI controlla gli aggiornamenti
Per prima cosa l'AI verifica da sé le versioni stabili di Superpowers e agent-skills (è il principio update-first) e te lo riferisce. Tu rispondi e basta.
🤖 "Le ultime stabili sono Superpowers v5.1.0 e agent-skills 0.6.1. Aggiorno il sistema prima di partire?" 👤 "sì"
Rispondi alle domande sull'architettura
L'AI ti intervista una domanda alla volta (cosa costruisci, web/API/mobile, scala, vincoli), poi raccomanda un preset e un'alternativa. Tu confermi o cambi — non devi conoscere i nomi dei preset.
🤖 "È un'app web, un'API o un'app mobile?" 👤 "un'API in Go" 🤖 "Consiglio go-fly-neon (Go + Fly.io + Neon). Alternativa: rust-axum-fly. Procedo?" 👤 "vai"
L'AI crea lo scaffold
L'AI genera i file dello stack scelto e installa il sistema multi-agente dentro il progetto. Tu non tocchi nulla: a fine lavoro te lo mostra e ti propone il passo dopo.
🤖 "Creato lo scaffold go-fly-neon in ./mio-servizio e installato il
sistema multi-agente. Procedo con la connessione degli strumenti?"
Conferma le connessioni agli strumenti
L'AI capisce quali strumenti servono allo stack (qui GitHub, Fly.io, Neon), verifica le CLI e fa il login su tua conferma. Le chiavi segrete le inserisci tu in .env.local: l'AI non le inventa né le scrive nel repo.
🤖 "Per go-fly-neon servono GitHub, Fly.io e Neon. La CLI di Fly.io non risulta installata: ti guido a installarla e fare il login?" 👤 "sì, procedi"
.env.local (già in .gitignore) — l'AI non li scrive mai nei file versionati.Sviluppa continuando a parlare
Da qui chiedi quello che ti serve, sempre in linguaggio naturale. L'AI segue il ciclo spec → piano → sviluppo TDD → review, e si ferma ai gate (spec, piano, pre-deploy) per il tuo via libera.
👤 "aggiungi un endpoint di login con JWT" 🤖 "Ho preparato la spec. La approvi prima che passi al piano?" 👤 "approvo"
Chiedi una verifica quando vuoi
Puoi sempre chiedere all'AI di validare il lavoro: lancerà lei i test (lo stesso dry-run che gira in CI) e ti riporterà l'esito.
👤 "verifica che tutti i preset siano a posto" 🤖 "Eseguito il dry-run, senza rete né provisioning: ✓ tutti i 13 preset OK."
./forge.sh new, check, test) — vedi Installazione & avvio › CLI pura. Ma nell'uso normale lasci guidare l'AI.Comandi
Riferimento per chi usa la CLI; nell'uso normale li lancia l'AI per te.
| Comando | Cosa fa |
|---|---|
./forge.sh new | Wizard completo: update → architettura → scaffold → connessione strumenti |
./forge.sh update | Risolve e registra le versioni stabili più recenti del sistema multi-agente |
./forge.sh check | Solo verifica aggiornamenti (nessuna scrittura) |
./forge.sh test | Dry-run di scaffolding per ogni preset (CI-friendly) |
./forge.sh doctor | Mostra quali CLI sono disponibili nell'ambiente |
./forge.sh help | Sintesi dei comandi |
Preset disponibili
Tredici stack pronti all'uso. Ognuno porta con sé scaffold, variabili d'ambiente e la guida di connessione degli strumenti.
| Preset | Stack | Strumenti |
|---|---|---|
nextjs-supabase-vercel | Next.js (App Router) + Supabase + Vercel | github, supabase, vercel |
node-ts-railway-postgres | Node/TypeScript API (Fastify) + Postgres | github, railway |
python-fastapi-railway | Python / FastAPI | github, railway |
astro-cloudflare | Astro (static/SSR) + Cloudflare Pages/Workers | github, cloudflare |
cloudflare-workers-hono | Cloudflare Workers + Hono (TS) + D1 | github, cloudflare |
go-fly-neon | API Go + Fly.io + Neon Postgres | github, fly, neon |
sveltekit-render-neon | SvelteKit + Render + Neon Postgres | github, render, neon |
expo-react-native | Expo / React Native (mobile) + EAS | github, eas |
django-fly-neon | Django (Python) + Fly.io + Neon | github, fly, neon |
rust-axum-fly | Rust (Axum) API + Fly.io + Neon | github, fly, neon |
springboot-kotlin-fly-neon | Spring Boot (Kotlin) + Fly.io + Neon | github, fly, neon |
ktor-kotlin-fly-neon | Ktor (Kotlin) + Fly.io + Neon | github, fly, neon |
generic | Composto dal wizard in base alle risposte | github (+ a scelta) |
Modalità d'installazione
Il sistema multi-agente può essere installato in due modi; WellForge sceglie da solo (plugin se trova la CLI claude, altrimenti vendor).
Plugin — consigliato con Claude Code
# Superpowers (marketplace ufficiale) /plugin install superpowers@claude-plugins-official # agent-skills di Addy Osmani /plugin marketplace add addyosmani/agent-skills /plugin install agent-skills@addy-agent-skills
Vendor — qualsiasi agente
Clona i due repo all'ultima versione stabile in .forge/vendor/ e copia le skill in .claude/skills/. Nessuna dipendenza da Claude.
CI (GitHub Actions)
.github/workflows/ci.yml gira a ogni push e pull request con due job:
test · bloccante
bash -n su tutti gli script, ShellCheck, ./forge.sh test e validazione di ogni stack.json. Se un preset si rompe, la CI fallisce.
update-check · non bloccante
Risolve le ultime versioni stabili del sistema multi-agente e ti segnala quando conviene un ./forge.sh update. Non rompe la build se GitHub è rate-limited.
Crediti & licenze
WellForge è un layer di orchestrazione: non ridistribuisce i due sistemi, li installa o clona dalle fonti ufficiali alle versioni stabili che risolvi tu.
| Sistema | Autore | Licenza |
|---|---|---|
| Superpowers | Jesse Vincent (obra) | MIT |
| agent-skills | Addy Osmani | MIT |