convez.ai
AgenteDesenvolvimento WebIntermediário
matiaspautasso

UIForge — Gerador de Componentes UI com IA

matiaspautasso/ai-front-tools

Coleta padrões web e forja componentes production-ready para seu frontend

Ver no GitHub
InicialPluginScore · de 0 a 100

Agent kit que coleta padrões de UI reais da web e gera componentes prontos para produção em qualquer stack frontend. Integra-se nativamente com Claude Code, Codex, Cursor e GitHub Copilot, automatizando a detecção de stack e adaptação de designs.

Instalação

$npx convez-ai matiaspautasso/ai-front-tools

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
0
Forks
0
Acompanhando
0
Saúde
28%
Último commit
há 5 meses
Versão
—
Issues abertas
0
Contribuidores
1

Casos de uso

  • Acelerar prototipagem de interfaces com padrões comprovados
  • Gerar componentes personalizados para React, Vue, Angular, Svelte ou Astro
  • Automatizar manutenção de consistência visual e acessibilidade

Veredito

UIForge é uma abordagem sólida para automação de componentes UI, com bom suporte multiplataforma e integração nativa a IDEs com IA. O design local (sem cloud dependency) é uma força, mas depende de configuração manual de adapters para cada runtime.

README

A tradução para o português deste README ainda está na fila.

UIForge

A plug-and-play AI agent system that harvests UI patterns from the web
and forges production-ready components for any frontend stack.

  ██╗   ██╗██╗███████╗ ██████╗ ██████╗  ██████╗ ███████╗
  ██║   ██║██║██╔════╝██╔═══██╗██╔══██╗██╔════╝ ██╔════╝
  ██║   ██║██║█████╗  ██║   ██║██████╔╝██║  ███╗█████╗
  ██║   ██║██║██╔══╝  ██║   ██║██╔══██╗██║   ██║██╔══╝
  ╚██████╔╝██║██║     ╚██████╔╝██║  ██║╚██████╔╝███████╗
   ╚═════╝ ╚═╝╚═╝      ╚═════╝ ╚═╝  ╚═╝ ╚═════╝ ╚══════╝

Works with Claude Code · Codex · Cursor · GitHub Copilot


How to implement

1. Copy the .claude/ folder into your project root

cp -r ui-forge/.claude /your-project/.claude

2. Open your AI assistant in the project and run one command

/frontend-init

That's it. UIForge will:

  • Detect your stack automatically (React, Next.js, Vue, Angular, Svelte, Astro…)
  • Run a short design discovery session (5 questions, ~3 minutes)
  • Fetch UI patterns from 8 curated gallery sites
  • Generate adapter files for your AI runtime (Codex / Cursor / Copilot)
  • Be ready to generate components

Using Codex, Cursor, or Copilot?

After running /frontend-init in Claude Code once, copy the generated adapter to your project:

RuntimeFile to copy
Codex.claude/frontend/adapters/AGENTS.md → project root
Cursor.claude/frontend/adapters/.cursorrules → project root
Copilot.claude/frontend/adapters/copilot-instructions.md → .github/

What is this?

UIForge is a project-local agent kit — not a framework, not a CLI tool, not an npm package.
It's a set of specialized AI agents and skills that live in your .claude/ folder and travel with your repo.

┌─────────────────────────────────────────────────────────────────┐
│                        UIForge System                           │
│                                                                 │
│   /frontend-init          /frontend-build         /frontend-qa  │
│         │                       │                      │        │
│         ▼                       ▼                      ▼        │
│  ┌─────────────┐       ┌──────────────┐       ┌─────────────┐  │
│  │   Stack     │       │  Orchestrator│       │  Visual QA  │  │
│  │  Detector   │       │              │       │  Playwright │  │
│  └──────┬──────┘       └──────┬───────┘       │  axe-core   │  │
│         │                     │               └─────────────┘  │
│         ▼                     ▼                                 │
│  stack.json          ┌────────────────┐                        │
│                      │  brief.json +  │                        │
│  Discovery Session   │  kb/*.json     │                        │
│  (5 questions)       └────────┬───────┘                        │
│                               │                                 │
│                               ▼                                 │
│                      ┌────────────────┐                        │
│                      │    Builder     │  React / Next / Vue /  │
│                      │  (stack-aware) │  Angular / Svelte /    │
│                      └────────────────┘  Astro                 │
└─────────────────────────────────────────────────────────────────┘

Every component it generates knows about your product, your brand, your tokens, and your stack — because it read your design brief first.


What it solves

Starting a new UI from scratch is slow and inconsistent.

You open a blank file, guess at spacing, pick colors from memory, and end up with components that don't feel like a coherent product. Then you spend hours searching Dribbble, Tailwind UI, and GitHub for inspiration — copy-pasting things that don't quite fit.

UIForge solves this by:

  • Grounding every component in your design brief — not generic boilerplate
  • Harvesting real patterns from the best UI galleries on the web — headlines, CTAs, hero sections, navbars, 404s, bento grids, footers, icon sets
  • Synthesizing those patterns into a coherent style direction — so your hero and your footer feel like they belong to the same product
  • Generating framework-native code — not a one-size-fits-all React snippet, but actual Next.js App Router server components, or Angular standalone components with signals, or Svelte SFCs
  • Validating the output — responsive check, WCAG contrast, keyboard accessibility, overflow detection

What you get

After /frontend-init:

  .claude/frontend/
  ├── brief.json          ← Your product's visual DNA
  ├── stack.json          ← Detected framework + toolchain
  ├── kb/
  │   ├── h1-patterns.json        8 gallery sources,
  │   ├── cta-patterns.json       curated locally,
  │   ├── hero-patterns.json      no network on every
  │   ├── navbar-patterns.json    generation request
  │   ├── 404-patterns.json
  │   ├── bento-patterns.json
  │   ├── footer-patterns.json
  │   └── icons.json
  └── adapters/
      ├── AGENTS.md               Codex-ready
      ├── .cursorrules            Cursor-ready
      └── copilot-instructions.md Copilot-ready


After /frontend-build hero:

  src/components/landing/Hero.tsx     (or .vue / .astro / etc.)
  → Matches your brand adjectives
  → Uses your color tokens
  → Implements the hero layout pattern from your brief
  → Accessible, responsive, all states handled


After /frontend-qa src/components/landing:

  .claude/frontend/qa-report.json
  → Responsive: ✓ mobile / ✓ tablet / ✓ desktop
  → Contrast: 2 warnings (details inside)
  → Overflow: ✓ clean
  → Focus: ✓ visible on all interactive elements

Agents

┌─────────────────────────────────────────────────────────────────┐
│  LAYER 1 — ORCHESTRATION                                        │
│                                                                 │
│  ┌──────────────────────────────────┐                          │
│  │      frontend-orchestrator       │  Reads brief + delegates │
│  │  Never writes code. Always asks. │  Blocks if brief missing │
│  └──────────────────────────────────┘                          │
└─────────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────────┐
│  LAYER 2 — GALLERY AGENTS  (web → kb/)                         │
│                                                                 │
│  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐            │
│  │ frontend-h1 │  │frontend-cta │  │frontend-hero│            │
│  │h1gallery.com│  │ cta.gallery │  │ supahero.io │            │
│  └─────────────┘  └─────────────┘  └─────────────┘            │
│                                                                 │
│  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐            │
│  │frontend-    │  │frontend-404 │  │frontend-    │            │
│  │navbar       │  │ 404s.design │  │bento        │            │
│  │navbar.gallery│ └─────────────┘  │bentogrids   │            │
│  └─────────────┘                   └─────────────┘            │
│                                                                 │
│  ┌─────────────┐  ┌─────────────┐                             │
│  │frontend-    │  │frontend-    │                             │
│  │footer       │  │icons        │                             │
│  │footer.design│  │iconify.design│                            │
│  └─────────────┘  └─────────────┘                             │
└─────────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────────┐
│  LAYER 3 — SYNTHESIS                                            │
│                                                                 │
│  ┌──────────────────────────────────┐                          │
│  │      frontend-synthesizer        │                          │
│  │  Reads all kb/ + brief.json      │                          │
│  │  Detects style conflicts         │                          │
│  │  Writes style_tokens to brief    │                          │
│  └──────────────────────────────────┘                          │
└─────────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────────┐
│  LAYER 4 — GENERATION                                           │
│                                                                 │
│  ┌──────────────────────────────────┐                          │
│  │       frontend-builder           │  next · react · vue      │
│  │  brief + stack + kb/<domain>     │  angular · svelte · astro│
│  │  → framework-native component    │  tailwind · scss · css   │
│  └──────────────────────────────────┘  shadcn · radix · material│
└─────────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────────┐
│  LAYER 5 — QUALITY                                              │
│                                                                 │
│  ┌──────────────────────────────────┐                          │
│  │         frontend-qa              │  Playwright              │
│  │  responsive · contrast · a11y    │  axe-core                │
│  │  overflow · focus visibility     │  WCAG AA                 │
│  └──────────────────────────────────┘                          │
└─────────────────────────────────────────────────────────────────┘

Skills (Commands)

┌──────────────────┬────────────────────────────────────────────┐
│ Command          │ What it does                               │
├──────────────────┼────────────────────────────────────────────┤
│ /frontend-init   │ Stack detect → discovery session →         │
│                  │ KB harvest → adapter generation            │
│                  │ Run this once per project                  │
├──────────────────┼────────────────────────────────────────────┤
│ /frontend-build  │ Generate a component from your brief       │
│   <component>    │ Examples:                                  │
│                  │   /frontend-build hero                     │
│                  │   /frontend-build navbar                   │
│                  │   /frontend-build 404                      │
│                  │   /frontend-build bento-features           │
├──────────────────┼────────────────────────────────────────────┤
│ /frontend-refresh│ Re-fetch galleries and update kb/          │
│   [domain]       │   /frontend-refresh        (all domains)  │
│                  │   /frontend-refresh h1      (one domain)   │
│                  │   /frontend-refresh --force (ignore cache) │
├──────────────────┼────────────────────────────────────────────┤
│ /frontend-qa     │ Run visual QA on a component or path       │
│   [path]         │   /frontend-qa src/components/landing      │
└──────────────────┴────────────────────────────────────────────┘

Knowledge base sources

AgentSourceWhat it extracts
frontend-h1h1gallery.comHeadline formulas, tone, word count, copy patterns
frontend-ctacta.galleryButton copy, primary/secondary types, urgency triggers
frontend-herosupahero.ioLayout composition, above-the-fold elements, social proof
frontend-navbarnavbar.galleryNav types, CTA placement, mobile patterns
frontend-404404s.designError page styles, copy tone, recovery CTAs
frontend-bentobentogrids.comGrid proportions, card hierarchy, responsive patterns
frontend-footerfooter.designFooter structures, link architecture, newsletter forms
frontend-iconsiconify.designFree icon sets, license validation, semantic mapping

All data is stored locally in .claude/frontend/kb/ after the first fetch.
Galleries are only re-fetched when you explicitly run /frontend-refresh.


Stack support

FrameworkSupported
React (Vite / CRA)✓
Next.js 13+ (App Router)✓
Next.js (Pages Router)✓
Vue 3✓
Nuxt 3✓
Angular 17+ (standalone)✓
Svelte / SvelteKit✓
Astro✓
CSSSupported
Tailwind CSS✓
SCSS / CSS Modules✓
styled-components✓
Component LibrarySupported
shadcn/ui✓
Radix UI✓
Material UI✓
PrimeNG (Angular)✓
None (semantic HTML)✓

Project structure

ui-forge/
├── .claude/
│   ├── agents/          12 specialized agents
│   ├── skills/          4 workflow skills
│   └── frontend/        runtime state (gitignored in target projects)
├── docs/
│   └── superpowers/
│       └── specs/       design documentation
└── README.md

License

Free to use, extend, and adapt for your projects.
Gallery sources are publicly available and free. Icon sets via Iconify are individually licensed — UIForge validates and selects only free/open licenses.

Ver o original no GitHub

Bom para

Relacionados