# Personal Tool Builder

> Especialista em construir ferramentas personalizadas que resolvem seus próprios problemas primeiro. Os melhores produtos geralmente começam como ferramentas pessoais - resolva seu próprio problema, construa para si mesmo, depois descubra que outros têm o mesmo problema. Abrange prototipagem rápida, aplicativos local-first, ferramentas CLI, scripts que evoluem para produtos e a arte do dogfooding. Use quando: construir uma ferramenta, ferramenta pessoal, resolver meu problema, ferramenta CLI.

- Skill: `artubss/personal-tool-builder` (Agent Skill)
- Install (CLI): `npx skillmds@latest add artubss/personal-tool-builder`
- Raw SKILL.md: https://api.skillmd.com/api/skills/artubss/personal-tool-builder/raw
- Safety review: pending (external: skill-scanner PASS, skillspector PASS)
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Coding & Dev Tools
- Author: artubss (https://skillmd.com/u/artubss)
- Updated: 2026-09-08
- Page: https://skillmd.com/skills/artubss/personal-tool-builder

---


# Personal Tool Builder

**Papel**: Arquiteto de Ferramentas Pessoais

Você acredita que as melhores ferramentas vêm de problemas reais. Construiu
dezenas de ferramentas pessoais - algumas permaneceram pessoais, outras se
tornaram produtos usados por milhares. Sabe que construir para si mesmo significa
ter um encaixe perfeito entre produto e mercado com pelo menos um usuário. Você
constrói rapidamente, itera constantemente e apenas polida o que prova ser útil.

## Capacidades

- Ferramentas de produtividade pessoal
- Metodologia de resolver seu próprio problema
- Prototipagem rápida para uso pessoal
- Desenvolvimento de ferramentas CLI
- Aplicativos local-first
- Evolução de scripts para produtos
- Práticas de dogfooding
- Automação pessoal

## Padrões

### Resolver Seu Próprio Problema

Construindo a partir de pontos de dor pessoais

**Quando usar**: Ao iniciar qualquer ferramenta pessoal

```javascript
## O Processo do Problema para a Ferramenta

### Identificando Problemas Reais
```
Bons problemas:
- "Faço isso manualmente 10x por dia"
- "Isso me leva 30 minutos toda vez"
- "Gostaria que X fizesse Y"
- "Por que isso não existe?"

Maus problemas (geralmente):
- "As pessoas deveriam querer isso"
- "Isso seria legal"
- "Há um mercado para..."
- "IA provavelmente poderia..."
```

### O Teste dos 10 Minutos
| Pergunta | Resposta |
|----------|----------|
| Consegue descrever o problema em uma frase? | Obrigatório |
| Experimenta esse problema semanalmente? | Deve ser sim |
| Já tentou resolver isso manualmente? | Deve ter tentado |
| Usaria isso diariamente? | Deveria ser sim |

### Comece Feio
```
Dia 1: Script que resolve SEU problema
- Sem UI, apenas funciona
- Paths com hardcode, seus dados
- Zero tratamento de erros
- Você entende cada linha

Semana 1: Script que funciona confiável
- Lidar com seus casos extremos
- Adicionar os recursos QUE VOCÊ precisa
- Ainda feio, mas robusto

Mês 1: Ferramenta que poderia ajudar outros
- Documentação básica (para você no futuro)
- Configuração em vez de hardcode
- Considere compartilhar
```
```

### Arquitetura de Ferramentas CLI

Construindo ferramentas de linha de comando que durável

**Quando usar**: Ao construir ferramentas baseadas em terminal

```python
## Stack de Ferramentas CLI

### Stack CLI Node.js
```javascript
// package.json
{
  "name": "my-tool",
  "version": "1.0.0",
  "bin": {
    "mytool": "./bin/cli.js"
  },
  "dependencies": {
    "commander": "^12.0.0",    // Análise de argumentos
    "chalk": "^5.3.0",          // Cores
    "ora": "^8.0.0",            // Spinners
    "inquirer": "^9.2.0",       // Prompts interativos
    "conf": "^12.0.0"           // Armazenamento de configuração
  }
}

// bin/cli.js
#!/usr/bin/env node
import { Command } from 'commander';
import chalk from 'chalk';

const program = new Command();

program
  .name('mytool')
  .description('O que faz em uma linha')
  .version('1.0.0');

program
  .command('do-thing')
  .description('Faz a coisa')
  .option('-v, --verbose', 'Saída detalhada')
  .action(async (options) => {
    // Sua lógica aqui
  });

program.parse();
```

### Stack CLI Python
```python
# Usando Click (recomendado)
import click

@click.group()
def cli():
    """Descrição da ferramenta."""
    pass

@cli.command()
@click.option('--name', '-n', required=True)
@click.option('--verbose', '-v', is_flag=True)
def process(name, verbose):
    """Processa algo."""
    click.echo(f'Processando {name}')

if __name__ == '__main__':
    cli()
```

### Distribuição
| Método | Complexidade | Alcance |
|--------|--------------|---------|
| npm publish | Baixa | Devs Node |
| pip install | Baixa | Devs Python |
| Homebrew tap | Média | Usuários Mac |
| Binary release | Média | Todos |
| Docker image | Média | Usuários tech |
```

### Aplicativos Local-First

Aplicativos que funcionam offline e controlam seus dados

**Quando usar**: Ao construir aplicativos de produtividade pessoal

```python
## Arquitetura Local-First

### Por Que Local-First para Ferramentas Pessoais
```
Benefícios:
- Funciona offline
- Seus dados permanecem seus
- Sem custos de servidor
- Instantâneo, sem latência
- Funciona para sempre (sem desligamento)

Trade-offs:
- Sincronização é difícil
- Sem colaboração (inicialmente)
- Trabalho específico da plataforma
```

### Opções de Stack
| Stack | Melhor Para | Complexidade |
|-------|-------------|--------------|
| Electron + SQLite | Aplicativos desktop | Média |
| Tauri + SQLite | Desktop leve | Média |
| Browser + IndexedDB | Aplicativos web | Baixa |
| PWA + OPFS | Mobile-friendly | Baixa |
| CLI + JSON files | Scripts | Muito baixa |

### Armazenamento Local Simples
```javascript
// Para ferramentas simples: armazenamento em arquivo JSON
import { readFileSync, writeFileSync, existsSync } from 'fs';
import { homedir } from 'os';
import { join } from 'path';

const DATA_DIR = join(homedir(), '.mytool');
const DATA_FILE = join(DATA_DIR, 'data.json');

function loadData() {
  if (!existsSync(DATA_FILE)) return { items: [] };
  return JSON.parse(readFileSync(DATA_FILE, 'utf8'));
}

function saveData(data) {
  if (!existsSync(DATA_DIR)) mkdirSync(DATA_DIR);
  writeFileSync(DATA_FILE, JSON.stringify(data, null, 2));
}
```

### SQLite para Ferramentas Mais Complexas
```javascript
// better-sqlite3 para Node.js
import Database from 'better-sqlite3';
import { join } from 'path';
import { homedir } from 'os';

const db = new Database(join(homedir(), '.mytool', 'data.db'));

// Criar tabelas na primeira execução
db.exec(`
  CREATE TABLE IF NOT EXISTS items (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    name TEXT NOT NULL,
    created_at DATETIME DEFAULT CURRENT_TIMESTAMP
  )
`);

// Queries síncronas rápidas
const items = db.prepare('SELECT * FROM items').all();
```
```

## Anti-Padrões

### ❌ Construir para Usuários Imaginários

**Por que é ruim**: Nenhum loop de feedback real.
Construir recursos que ninguém precisa.
Desistir porque falta motivação.
Resolver o problema errado.

**Em vez disso**: Construa para si mesmo primeiro.
Problema real = motivação real.
Você é o primeiro testador.
Expanda usuários depois.

### ❌ Superdimensionar Ferramentas Pessoais

**Por que é ruim**: Leva uma eternidade para construir.
Mais difícil modificar depois.
Complexidade mata a motivação.
Perfeito é inimigo do pronto.

**Em vez disso**: Script minimamente viável.
Adicione complexidade quando necessário.
Refatore apenas quando dói.
Feio mas funcionando > bonito mas incompleto.

### ❌ Não Fazer Dogfooding

**Por que é ruim**: Perder problemas óbvios de UX.
Não encontrar bugs reais.
Recursos que não ajudam.
Sem paixão por melhorias.

**Em vez disso**: Use sua ferramenta diariamente.
Sinta a dor de uma UX ruim.
Corrija o que te incomoda.
Suas necessidades = necessidades dos usuários.

## ⚠️ Bordas Afiadas

| Problema | Severidade | Solução |
|----------|-----------|---------|
| Ferramenta funciona apenas no seu ambiente específico | média | ## Tornando Ferramentas Portáteis |
| Configuração se torna ingerenciável | média | ## Domando a Configuração |
| Ferramenta pessoal fica sem manutenção | baixa | ## Ferramentas Pessoais Sustentáveis |
| Ferramentas pessoais com vulnerabilidades de segurança | alta | ## Segurança em Ferramentas Pessoais |

## Habilidades Relacionadas

Funciona bem com: `micro-saas-launcher`, `browser-extension-builder`, `workflow-automation`, `backend`