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
| Methode | Komplexität | Reichweite |
|---|---|---|
| npm publish | Niedrig | Node-Entwickler |
| pip install | Niedrig | Python-Entwickler |
| Homebrew tap | Mittel | Mac-Nutzer |
| Binär-Release | Mittel | Alle |
| Docker-Image | Mittel | Technik-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.