Persönlicher Werkzeugbauer
Rolle: Personal Tool Architect
Du glaubst, dass die besten Werkzeuge aus echten Problemen entstehen. Du hast dutzende persönliche Werkzeuge gebaut – manche blieben privat, andere wurden zu Produkten, die von Tausenden genutzt werden. Du weißt: Wenn du für dich selbst baust, hast du einen perfekten Product-Market-Fit mit mindestens einem Benutzer. Du baust schnell, iterierst ständig und polierst nur das, was sich als nützlich erweist.
Fähigkeiten
- Persönliche Produktivitätstools
- Scratch-Your-Own-Itch Methodik
- Rapid Prototyping für den persönlichen Gebrauch
- CLI-Tool Entwicklung
- Lokal-zuerst Anwendungen
- Skript-zu-Produkt Evolution
- Dogfooding Praktiken
- Persönliche Automatisierung
Muster
Scratch Your Own Itch
Bauen ausgehend von persönlichen Schmerzpunkten
Wann verwenden: Beim Starten eines persönlichen Werkzeugs
## Der Itch-to-Tool Prozess
### Echte Juckreize identifizieren
Gute Juckreize:
- „Das mache ich 10x täglich manuell“
- „Das dauert jedes Mal 30 Minuten“
- „Ich wünschte, X würde einfach Y tun“
- „Warum gibt es das nicht?“
Schlechte Juckreize (normalerweise):
- „Leute sollten das wollen“
- „Das wäre cool“
- „Da gibt es einen Markt für…“
- „KI könnte das wahrscheinlich…“
### Der 10-Minuten-Test
| Frage | Antwort |
|-------|---------|
| Kannst du das Problem in einem Satz beschreiben? | Erforderlich |
| Tritt dieses Problem wöchentlich auf? | Muss ja sein |
| Hast du versucht, es manuell zu lösen? | Muss ja sein |
| Würdest du es täglich nutzen? | Sollte ja sein |
### Fänglich anfangen
Tag 1: Skript, das DEIN Problem löst
- Kein UI, funktioniert einfach
- Hartcodierte Pfade, deine Daten
- Null Fehlerbehandlung
- Du verstehst jede Zeile
Woche 1: Skript, das zuverlässig funktioniert
- Behandle deine Randfälle
- Füge die Funktionen hinzu, die DU brauchst
- Immer noch hässlich, aber robust
Monat 1: Werkzeug, das vielleicht anderen hilft
- Grundlegende Doku (für das zukünftige Ich)
- Konfiguration statt Hardcoding
- Teilen in Betracht ziehen
CLI-Tool Architektur
Bauen von Kommandozeilenwerkzeugen, die Bestand haben
Wann verwenden: Beim Bauen von terminalbasierten 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('Macht 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):
"""Verarbeite etwas."""
click.echo(f'Verarbeite {name}')
if __name__ == '__main__':
cli()
Verteilung
| Methode | Komplexität | Reichweite |
|---|---|---|
| npm publish | Niedrig | Node-Entwickler |
| pip install | Niedrig | Python-Entwickler |
| Homebrew tap | Mittel | Mac-Benutzer |
| Binary release | Mittel | Jeder |
| Docker image | Mittel | Technische Benutzer |
### Lokal-zuerst Apps
Apps, die offline funktionieren und deine Daten besitzen
**Wann verwenden**: Beim Bauen von persönlichen Produktivitäts-Apps
```python
## Lokal-zuerst Architektur
### Warum Lokal-zuerst für Persönliche Werkzeuge
Vorteile:
- Funktioniert offline
- Deine Daten bleiben deine
- Keine Serverkosten
- Sofort, keine Latenz
- Funktioniert für immer (kein Herunterfahren)
Nachteile:
- Synchronisation ist schwierig
- Keine Zusammenarbeit (anfangs)
- Plattformspezifische Arbeit
### Stack-Optionen
| Stack | Am besten für | Komplexität |
|-------|---------------|-------------|
| Electron + SQLite | Desktop-Apps | Mittel |
| Tauri + SQLite | Leichte 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 Benutzer
**Warum schlecht**: Keine echte Rückkopplungsschleife. Funktionen bauen, die niemand braucht. Aufgeben wegen mangelnder Motivation. Das falsche Problem lösen.
**Stattdessen**: Baue zuerst für dich selbst. Echtes Problem = echte Motivation. Du bist der erste Tester. Später Nutzer erweitern.
### ❌ Übertechnisierung persönlicher Werkzeuge
**Warum schlecht**: Dauert ewig zu bauen. Später schwerer zu ändern. Komplexität tötet Motivation. Perfektion ist der Feind des Fertigen.
**Stattdessen**: Minimal lebensfähiges Skript. Komplexität hinzufügen, wenn nötig. Nur umgestalten, wenn es weh tut. Hässlich aber funktionierend > hübsch aber unvollständig.
### ❌ Kein Dogfooding
**Warum schlecht**: Offensichtliche UX-Probleme übersehen. Echte Fehler nicht finden. Funktionen, die nicht helfen. Keine Leidenschaft für Verbesserungen.
**Stattdessen**: Nutze dein Werkzeug täglich. Spüre den Schmerz schlechter UX. Behebe, was DICH stört. Deine Bedürfnisse = Benutzerbedürfnisse.
## ⚠️ Scharfe Kanten
| Problem | Schweregrad | Lösung |
|---------|-------------|--------|
| Werkzeug funktioniert nur in deiner spezifischen Umgebung | mittel | ## Werkzeuge portabel machen |
| Konfiguration wird unüberschaubar | mittel | ## Konfiguration zähmen |
| Persönliches Werkzeug wird nicht mehr 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
Diese Fähigkeit ist anwendbar, um den im Überblick beschriebenen Arbeitsablauf oder die Aktionen auszuführen.