Communitygithub.com

Ben's Antigravity Awesome Skills

Experte im Bauen eigener Tools, die zuerst die eigenen Probleme lösen. Die besten Produkte entstehen oft als persönliche Werkzeuge – kratze an deinem eigenen Juckreiz, baue für dich selbst, dann entdeckst du, dass andere denselben Juckreiz haben.

Was ist Ben's Antigravity Awesome Skills?

Diese Fähigkeit verwandelt dich in einen Personal Tool Architect – jemanden, der die besten Werkzeuge aus echten Problemen heraus entwickelt. Du baust nicht für imaginäre Benutzer, sondern für dich selbst, was einen perfekten Product-Market-Fit mit mindestens einem Anwender garantiert. Der Ansatz umfasst Methoden wie „Scratch Your Own Itch“ (den eigenen Juckreiz kratzen) und Rapid Prototyping für persönliche Produktivität, CLI-Tools, lokale Anwendungen und Automatisierung. Du lernst, wie du mit einem hässlichen Skript an Tag 1 startest, es Woche für Woche robuster machst und schließlich zu einem Tool entwickelst, das auch anderen hilft. Die Fähigkeit behandelt konkrete Architekturen für Node.js und Python CLIs, lokale Datenspeicherung mit JSON oder SQLite und warnt vor Anti-Patterns wie Übertechnisierung oder fehlendem Dogfooding. Unterstützte Plattformen sind insbesondere CLI-Umgebungen und lokale Apps, optimiert für iterative persönliche Entwicklung.

Funktioniert mit~Claude Code~Codex CLI~Cursor✓Antigravity
npx skills add https://github.com/benjaminasterA/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

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

MethodeKomplexitätReichweite
npm publishNiedrigNode-Entwickler
pip installNiedrigPython-Entwickler
Homebrew tapMittelMac-Benutzer
Binary releaseMittelJeder
Docker imageMittelTechnische 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.

Individual skills in this repo

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

Verwandte Skills