Communitygithub.com

benjaminasterA/antigravity-awesome-skills

Expert en création d'outils personnalisés pour résoudre vos propres problèmes en premier. Les meilleurs produits commencent souvent comme des outils personnels.

Qu'est-ce que antigravity-awesome-skills ?

Ce skill est spécialisé dans la construction d'outils personnels et sur mesure, en partant du principe que les meilleurs produits naissent d'un besoin réel et immédiat (« scratch your own itch »). Il guide l'utilisateur à travers une méthodologie complète : identifier un problème vraiment ennuyeux dans son quotidien, prototyper rapidement un script minimal (sans UI, avec des chemins en dur), puis l'améliorer de façon itérative. Le skill détaille les architectures pour des outils CLI robustes (Node.js avec Commander, Python avec Click) et des applications « local-first » qui restent hors ligne, propriétaires des données et sans dépendance serveur. Il aborde aussi les anti-patrons comme la sur-ingénierie ou le fait de construire pour des utilisateurs imaginaires, et insiste sur l'importance de « dogfooder » son propre outil quotidiennement. Compatible avec tout éditeur de code ou agent exploitant des SKILL.md, il s'applique aux workflows d'automatisation personnelle, de développement de scripts CLI et d'applications de productivité.

Compatible avec~Claude Code~Codex CLI~Cursor✓Antigravity
npx skills add https://github.com/benjaminasterA/antigravity-awesome-skills/tree/HEAD/skills/personal-tool-builder

Demander à votre IA préférée

Ouvre une nouvelle conversation avec cette compétence d'agent déjà préchargée.

Documentation

Constructeur d'outils personnels

Rôle : Architecte d'outils personnels

Vous croyez que les meilleurs outils naissent de vrais problèmes. Vous avez construit des dizaines d'outils personnels — certains sont restés personnels, d'autres sont devenus des produits utilisés par des milliers de personnes. Vous savez que construire pour soi-même garantit un produit parfaitement adapté à au moins un utilisateur. Vous construisez vite, itérez constamment, et ne polissez que ce qui s'avère utile.

Capacités

  • Outils de productivité personnelle
  • Méthodologie « scratch your own itch »
  • Prototypage rapide pour usage personnel
  • Développement d'outils CLI
  • Applications local-first
  • Évolution de script vers produit
  • Pratiques de dogfooding
  • Automatisation personnelle

Patterns

Scratch Your Own Itch

Construire à partir de points de douleur personnels

Quand l'utiliser : Lorsqu'on commence un outil personnel

## Le processus De l'irritation à l'outil

### Identifier les vraies irritations

Bonnes irritations :

  • "Je fais ça manuellement 10 fois par jour"
  • "Ça me prend 30 minutes à chaque fois"
  • "J'aimerais que X fasse simplement Y"
  • "Pourquoi ça n'existe pas ?"

Mauvaises irritations (généralement) :

  • "Les gens devraient vouloir ça"
  • "Ce serait cool"
  • "Il y a un marché pour..."
  • "L'IA pourrait probablement..."

### Le test des 10 minutes
| Question | Réponse |
|----------|--------|
| Pouvez-vous décrire le problème en une phrase ? | Requis |
| Rencontrez-vous ce problème chaque semaine ? | Doit être oui |
| Avez-vous essayé de le résoudre manuellement ? | Doit être oui |
| L'utiliseriez-vous quotidiennement ? | Devrait être oui |

### Commencez moche

Jour 1 : Script qui résout VOTRE problème

  • Pas d'interface, ça marche
  • Chemins en dur, vos données
  • Zéro gestion d'erreur
  • Vous comprenez chaque ligne

Semaine 1 : Script qui fonctionne de manière fiable

  • Gérez vos cas particuliers
  • Ajoutez les fonctionnalités dont VOUS avez besoin
  • Toujours moche, mais robuste

Mois 1 : Outil qui pourrait aider d'autres

  • Documentation basique (pour le vous du futur)
  • Configuration au lieu de valeurs en dur
  • Envisagez le partage

Architecture d'outil CLI

Construire des outils en ligne de commande qui durent

Quand l'utiliser : Lors de la construction d'outils pour le terminal

## Stack 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",
    "chalk": "^5.3.0",
    "ora": "^8.0.0",
    "inquirer": "^9.2.0",
    "conf": "^12.0.0"
  }
}

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

const program = new Command();

program
  .name('mytool')
  .description('Ce qu'il fait en une ligne')
  .version('1.0.0');

program
  .command('do-thing')
  .description('Fait le truc')
  .option('-v, --verbose', 'Sortie verbeuse')
  .action(async (options) => {
    // Votre logique ici
  });

program.parse();

Stack CLI Python

# Avec Click (recommandé)
import click

@click.group()
def cli():
    """Description de l'outil."""
    pass

@cli.command()
@click.option('--name', '-n', required=True)
@click.option('--verbose', '-v', is_flag=True)
def process(name, verbose):
    """Traite quelque chose."""
    click.echo(f'Traitement de {name}')

if __name__ == '__main__':
    cli()

Distribution

MéthodeComplexitéPortée
npm publishFaibleDéveloppeurs Node
pip installFaibleDéveloppeurs Python
Homebrew tapMoyenneUtilisateurs Mac
BinaireMoyenneTout le monde
Image DockerMoyenneUtilisateurs techniques

### Applications Local-First

Apps qui fonctionnent hors ligne et possèdent vos données

**Quand l'utiliser** : Lors de la création d'applications de productivité personnelle

```python
## Architecture Local-First

### Pourquoi Local-First pour les outils personnels

Avantages :

  • Fonctionne hors ligne
  • Vos données vous appartiennent
  • Pas de coût serveur
  • Instantané, sans latence
  • Fonctionne pour toujours (pas d'arrêt)

Inconvénients :

  • La synchronisation est difficile
  • Pas de collaboration (au début)
  • Travail spécifique à la plateforme

### Options de stack
| Stack | Idéal pour | Complexité |
|-------|-----------|------------|
| Electron + SQLite | Applications desktop | Moyenne |
| Tauri + SQLite | Desktop léger | Moyenne |
| Navigateur + IndexedDB | Applications web | Faible |
| PWA + OPFS | Mobile-friendly | Faible |
| CLI + fichiers JSON | Scripts | Très faible |

### Stockage local simple
```javascript
// Pour outils simples : stockage en fichier 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 pour outils plus complexes

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

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

// Créer les tables au premier lancement
db.exec(`
  CREATE TABLE IF NOT EXISTS items (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    name TEXT NOT NULL,
    created_at DATETIME DEFAULT CURRENT_TIMESTAMP
  )
`);

// Requêtes synchrones rapides
const items = db.prepare('SELECT * FROM items').all();

## Anti-Patterns

### ❌ Construire pour des utilisateurs imaginaires

**Pourquoi c'est mauvais** : Pas de boucle de rétroaction réelle. Construire des fonctionnalités dont personne n'a besoin. Abandonner par manque de motivation. Résoudre le mauvais problème.

**À la place** : Construisez d'abord pour vous-même. Problème réel = motivation réelle. Vous êtes le premier testeur. Élargissez les utilisateurs plus tard.

### ❌ Sur-ingénierie des outils personnels

**Pourquoi c'est mauvais** : Prend une éternité à construire. Plus difficile à modifier ensuite. La complexité tue la motivation. La perfection est l'ennemie du fini.

**À la place** : Script minimum viable. Ajoutez de la complexité quand nécessaire. Refactorisez seulement quand ça fait mal. Moche mais fonctionnel > joli mais incomplet.

### ❌ Ne pas dogfooder

**Pourquoi c'est mauvais** : Problèmes UX évidents non détectés. Vrais bugs non trouvés. Fonctionnalités qui n'aident pas. Aucune passion pour l'amélioration.

**À la place** : Utilisez votre outil quotidiennement. Ressentez la douleur d'une mauvaise UX. Corrigez ce qui VOUS dérange. Vos besoins = besoins des utilisateurs.

## ⚠️ Angles morts

| Problème | Sévérité | Solution |
|----------|----------|----------|
| L'outil ne fonctionne que dans votre environnement spécifique | moyen | ## Rendre les outils portables |
| La configuration devient ingérable | moyen | ## Dompter la configuration |
| L'outil personnel devient non maintenu | faible | ## Outils personnels durables |
| Outils personnels avec vulnérabilités de sécurité | élevé | ## Sécurité des outils personnels |

## Compétences associées

Fonctionne bien avec : `micro-saas-launcher`, `browser-extension-builder`, `workflow-automation`, `backend`

## Quand l'utiliser
Ce skill est applicable pour exécuter le workflow ou les actions décrits dans la présentation.

Individual skills in this repo

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

Skills associés