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éthode | Complexité | Portée |
|---|---|---|
| npm publish | Faible | Développeurs Node |
| pip install | Faible | Développeurs Python |
| Homebrew tap | Moyenne | Utilisateurs Mac |
| Binaire | Moyenne | Tout le monde |
| Image Docker | Moyenne | Utilisateurs 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.