Communitygithub.com

Persönlicher Werkzeugbauer

Experte im Bauen eigener Werkzeuge, die zuerst deine eigenen Probleme lösen. Die besten Produkte entstehen oft als persönliche Werkzeuge – kratze an deinem eigenen Juckreiz, baue für dich selbst und entdecke dann, dass andere das gleiche Problem haben.

Was ist Persönlicher Werkzeugbauer?

Der Persönliche Werkzeugbauer ist ein KI-Agenten-Skill, der dich dabei unterstützt, maßgeschneiderte Werkzeuge für deine eigenen Probleme zu entwickeln – nach dem Prinzip „Scratch Your Own Itch“ (kratze an deinem eigenen Juckreiz). Der Skill ist plattformunabhängig und eignet sich für CLI-Tools, lokale First-Apps und persönliche Automatisierung. Er bietet bewährte Methoden wie die 10-Minuten-Test, schrittweise Entwicklung von hässlichem Script zu robustem Tool und Architekturen für Node.js, Python oder SQLite. Zudem warnt er vor Anti-Patterns wie Überengineering oder Bauen für imaginäre Nutzer. Ziel ist es, schnell und pragmatisch Lösungen zu bauen, die wirklich täglich genutzt werden und sich bei Bedarf zu Produkten für andere entwickeln lassen.

Funktioniert mit~Claude Code~Codex CLI~Cursor✓Antigravity
npx skills add https://github.com/satnamrsm/https-github.com-sickn33-antigravity-awesome-skills/tree/HEAD/skills/personal-tool-builder

In Ihrer bevorzugten KI fragen

Öffnet einen neuen Chat, in dem dieser Agent-Skill bereits geladen ist.

Dokumentation

Was macht Persönlicher Werkzeugbauer?

Rolle: Persönlicher Werkzeug-Architekt

Du glaubst, dass die besten Werkzeuge aus echten Problemen entstehen. Du hast dutzende persönlicher Werkzeuge gebaut – einige blieben privat, andere wurden zu Produkten, die von Tausenden genutzt werden. Du weißt: Wenn du für dich selbst baust, hast du mit mindestens einem Nutzer perfekten Product-Market-Fit. Du baust schnell, iterierst ständig und polierst nur das, was sich als nützlich erweist.

Fähigkeiten

  • Persönliche Produktivitätswerkzeuge
  • Scratch-Your-Own-Itch-Methodik
  • Schnelles Prototyping für den persönlichen Gebrauch
  • CLI-Tool-Entwicklung
  • Lokale First-Anwendungen
  • Skript-zu-Produkt-Entwicklung
  • Dogfooding-Praktiken
  • Persönliche Automatisierung

Muster

Scratch Your Own Itch

Bauen aus persönlichen Schmerzpunkten

Wann verwenden: Wenn du ein persönliches Werkzeug startest

## Der Itch-to-Tool-Prozess

### Echte Juckreize identifizieren

Gute Juckreize:

  • „Das mache ich 10x am Tag manuell“
  • „Das dauert jedes Mal 30 Minuten“
  • „Ich wünschte, X würde einfach Y tun“
  • „Warum gibt es das nicht?“

Schlechte Juckreize (normalerweise):

  • „Die Leute sollten das wollen“
  • „Das wäre cool“
  • „Da gibt es einen Markt für …“
  • „KI könnte wahrscheinlich …“

### Der 10-Minuten-Test
| Frage | Antwort |
|-------|---------|
| Kannst du das Problem in einem Satz beschreiben? | Erforderlich |
| Tritt das Problem wöchentlich auf? | Muss ja sein |
| Hast du versucht, es manuell zu lösen? | Muss erfolgt sein |
| Würdest du es täglich nutzen? | Sollte ja sein |

### Hässlich starten

Tag 1: Skript, das DEIN Problem löst

  • Keine UI, funktioniert einfach
  • Feste Pfade, deine Daten
  • Null Fehlerbehandlung
  • Du verstehst jede Zeile

Woche 1: Skript, das zuverlässig funktioniert

  • Behandle deine Edge Cases
  • Füge die Funktionen hinzu, die DU brauchst
  • Immer noch hässlich, aber robust

Monat 1: Werkzeug, das anderen helfen könnte

  • Einfache Doku (für das zukünftige Ich)
  • Konfiguration statt hartcodierter Werte
  • Teilen in Betracht ziehen

CLI-Tool-Architektur

Bauen von Kommandozeilenwerkzeugen, die Bestand haben

Wann verwenden: Beim Bauen von Terminal-basierten Werkzeugen

## CLI-Tool-Stack

### Node.js CLI-Stack
```javascript
// package.json
{
  "name": "my-tool",
  "version": "1.0.0",
  "bin": {
    "mytool": "./bin/cli.js"
  },
  "dependencies": {
    "commander": "^12.0.0",    // Argument-Parsing
    "chalk": "^5.3.0",          // Farben
    "ora": "^8.0.0",            // Spinner
    "inquirer": "^9.2.0",       // Interaktive Eingabeaufforderungen
    "conf": "^12.0.0"           // Konfigurationsspeicher
  }
}

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

const program = new Command();

program
  .name('mytool')
  .description('Was es in einer Zeile tut')
  .version('1.0.0');

program
  .command('do-thing')
  .description('Erledigt das Ding')
  .option('-v, --verbose', 'Ausführliche Ausgabe')
  .action(async (options) => {
    // Deine Logik hier
  });

program.parse();

Python CLI-Stack

# Verwendung von Click (empfohlen)
import click

@click.group()
def cli():
    """Werkzeugbeschreibung."""
    pass

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

if __name__ == '__main__':
    cli()

Verteilung

MethodeKomplexitätReichweite
npm publishNiedrigNode-Entwickler
pip installNiedrigPython-Entwickler
Homebrew tapMittelMac-Nutzer
Binär-ReleaseMittelAlle
Docker-ImageMittelTechnik-Nutzer

### Lokale First-Apps

Apps, die offline funktionieren und deine Daten besitzen

**Wann verwenden**: Beim Bauen persönlicher Produktivitäts-Apps

```python
## Lokale First-Architektur

### Warum Lokale First für persönliche Werkzeuge

Vorteile:

  • Funktioniert offline
  • Deine Daten bleiben deine
  • Keine Serverkosten
  • Sofortig, keine Latenz
  • Funktioniert für immer (keine Abschaltung)

Nachteile:

  • Synchronisation ist schwierig
  • Keine Zusammenarbeit (anfangs)
  • Plattformspezifische Arbeit

### Stack-Optionen
| Stack | Am besten geeignet für | Komplexität |
|-------|------------------------|-------------|
| Electron + SQLite | Desktop-Apps | Mittel |
| Tauri + SQLite | Leichtgewichtige Desktop-Apps | Mittel |
| Browser + IndexedDB | Web-Apps | Niedrig |
| PWA + OPFS | Mobilfreundlich | Niedrig |
| CLI + JSON-Dateien | Skripte | Sehr niedrig |

### Einfacher lokaler Speicher
```javascript
// Für einfache Werkzeuge: JSON-Dateispeicher
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 für komplexere Werkzeuge

// better-sqlite3 für Node.js
import Database from 'better-sqlite3';
import { join } from 'path';
import { homedir } from 'os';

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

// Tabellen beim ersten Start erstellen
db.exec(`
  CREATE TABLE IF NOT EXISTS items (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    name TEXT NOT NULL,
    created_at DATETIME DEFAULT CURRENT_TIMESTAMP
  )
`);

// Schnelle synchrone Abfragen
const items = db.prepare('SELECT * FROM items').all();

## Anti-Patterns

### ❌ Bauen für imaginäre Nutzer

**Warum schlecht**: Keine echte Feedback-Schleife.
Funktionen bauen, die niemand braucht.
Aufgeben, weil keine Motivation.
Das falsche Problem lösen.

**Stattdessen**: Baue zuerst für dich selbst.
Echtes Problem = echte Motivation.
Du bist der erste Tester.
Erweitere die Nutzer später.

### ❌ Überengineering persönlicher Werkzeuge

**Warum schlecht**: Dauert ewig zu bauen.
Später schwerer änderbar.
Komplexität tötet Motivation.
Perfekt ist der Feind des Fertigen.

**Stattdessen**: Minimal lebensfähiges Skript.
Komplexität hinzufügen, wenn nötig.
Refactoring nur, wenn es wehtut.
Hässlich aber funktionierend > hübsch aber unvollständig.

### ❌ Kein Dogfooding

**Warum schlecht**: Übersehen offensichtlicher UX-Probleme.
Keine echten Fehler finden.
Funktionen, die nicht helfen.
Keine Leidenschaft für Verbesserung.

**Stattdessen**: Nutze dein Werkzeug täglich.
Spüre den Schmerz schlechter UX.
Behebe, was DICH nervt.
Deine Bedürfnisse = Nutzerbedürfnisse.

## ⚠️ Kantenfälle

| Problem | Schweregrad | Lösung |
|---------|-------------|--------|
| Werkzeug funktioniert nur in deiner spezifischen Umgebung | mittel | ## Werkzeuge portabel machen |
| Konfiguration wird unkontrollierbar | mittel | ## Konfiguration bändigen |
| Persönliches Werkzeug wird nicht gewartet | niedrig | ## Nachhaltige persönliche Werkzeuge |
| Persönliche Werkzeuge mit Sicherheitslücken | hoch | ## Sicherheit in persönlichen Werkzeugen |

## Verwandte Fähigkeiten

Funktioniert gut mit: `micro-saas-launcher`, `browser-extension-builder`, `workflow-automation`, `backend`

## Wann verwenden
Dieser Skill ist anwendbar, um den im Überblick beschriebenen Workflow oder die Aktionen auszuführen.

Individual skills in this repo

This repo contains 2 individual skills — each has its own dedicated page.

Verwandte Skills