Communitygithub.com

satnamrsm/https-github.com-sickn33-antigravity-awesome-skills

Expert dans la construction d'outils personnalisés qui résolvent d'abord vos propres problèmes. Les meilleurs produits commencent souvent comme des outils personnels – grattez votre propre démangeaison, construisez pour vous-même, puis découvrez que d'autres ont la même...

Qu'est-ce que https-github.com-sickn33-antigravity-awesome-skills ?

Cette compétence, intitulée « Personal Tool Builder », vous guide pour devenir un architecte d'outils personnels. Elle repose sur la philosophie « Scratch Your Own Itch » : résoudre d'abord vos propres problèmes réels et quotidiens, car les meilleurs produits naissent de besoins personnels. La compétence détaille des patterns concrets comme le prototypage rapide (du script fonctionnel au produit partagé en un mois), l'architecture d'outils CLI (avec des stacks Node.js ou Python, incluant des bibliothèques comme Commander ou Click), et le développement d'applications local-first (utilisant SQLite, IndexedDB ou de simples fichiers JSON). Elle met en garde contre les anti-patterns classiques : construire pour des utilisateurs imaginaires, sur-ingénierie, ou ne pas utiliser son propre outil. Idéale pour les développeurs qui souhaitent créer des utilitaires personnels, des automatisations ou des micro-SaaS, cette compétence est applicable sur toutes les plateformes d'agents (Claude Code, Cursor, Codex) et s'intègre bien avec des compétences connexes comme micro-saas-launcher ou workflow-automation.

Compatible avec~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

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 viennent de problèmes réels. 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 signifie que vous avez un produit parfaitement adapté à au moins un utilisateur. Vous construisez rapidement, itérez constamment et ne peaufinez que ce qui s'avère utile.

Capacités

  • Outils de productivité personnelle
  • Méthodologie "grattez votre propre démangeaison"
  • Prototypage rapide pour usage personnel
  • Développement d'outils CLI
  • Applications local-first
  • Évolution de script à produit
  • Pratiques de dogfooding
  • Automatisation personnelle

Patterns

Grattez Votre Propre Démangeaison

Construire à partir de points de douleur personnels

Quand l'utiliser : Lors du démarrage de tout outil personnel

## Le Processus Démangeaison-à-Outil

### Identifier de Vraies Démangeaisons

Bonnes démangeaisons :

  • "Je fais ceci manuellement 10 fois par jour"
  • "Cela me prend 30 minutes à chaque fois"
  • "J'aimerais que X fasse juste Y"
  • "Pourquoi cela n'existe pas ?"

Mauvaises démangeaisons (généralement) :

  • "Les gens devraient vouloir ceci"
  • "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 |
| Vivez-vous ce problème chaque semaine ? | Doit être oui |
| Avez-vous essayé de le résoudre manuellement ? | Doit avoir essayé |
| L'utiliseriez-vous quotidiennement ? | Devrait être oui |

### Commencez Moche

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

  • Pas d'interface, ça marche juste
  • 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 de base (pour vous futur)
  • Configuration au lieu de code en dur
  • Envisagez de partager

Architecture d'Outils CLI

Construire des outils en ligne de commande qui durent

Quand l'utiliser : Lors de la construction d'outils basés sur le terminal

## Stack d'Outils CLI

### Stack Node.js CLI
```javascript
// package.json
{
  "name": "my-tool",
  "version": "1.0.0",
  "bin": {
    "mytool": "./bin/cli.js"
  },
  "dependencies": {
    "commander": "^12.0.0",    // Analyse des arguments
    "chalk": "^5.3.0",          // Couleurs
    "ora": "^8.0.0",            // Spinners
    "inquirer": "^9.2.0",       // Invites interactives
    "conf": "^12.0.0"           // Stockage de configuration
  }
}

// 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 verbose')
  .action(async (options) => {
    // Votre logique ici
  });

program.parse();

Stack Python CLI

# Utilisation de 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):
    """Traiter 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

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

**Quand l'utiliser** : Lors de la construction 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ûts de serveur
  • Instantané, pas de latence
  • Fonctionne pour toujours (pas d'arrêt)

Compromis :

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

### Options de Stack
| Stack | Meilleur 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 par 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 plus tard. La complexité tue la motivation. Le parfait est l'ennemi du fini.

**À la place** : Script minimal viable. Ajoutez de la complexité quand c'est nécessaire. Refactorez uniquement quand ça fait mal. Moche mais fonctionnel > joli mais incomplet.

### ❌ Ne Pas Dogfooder

**Pourquoi c'est mauvais** : Passer à côté de problèmes UX évidents. Ne pas trouver de vrais bugs. Fonctionnalités qui n'aident pas. Pas de 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 | Gravité | Solution |
|----------|---------|----------|
| L'outil ne fonctionne que dans votre environnement spécifique | moyenne | ## Rendre les Outils Portables |
| La configuration devient ingérable | moyenne | ## Dompter la Configuration |
| L'outil personnel devient non maintenu | faible | ## Outils Personnels Durables |
| Outils personnels avec vulnérabilités de sécurité | élevée | ## Sécurité dans les Outils Personnels |

## Compétences Connexes

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

## Quand Utiliser
Cette compétence est applicable pour exécuter le workflow ou les actions décrites dans l'aperçu.

Individual skills in this repo

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

Skills associés