Compétences golang-pro
📦
golang-pro
Risque faible ⚡
Contient des scripts⚙️
Commandes externes🌐
Accès réseau📁
Accès au système de fichiers🔑
Variables d’environnement
Créer des applications Go de production
La construction d'applications Go nécessite une compréhension approfondie des modèles de concurrence, des génériques et de l'architecture microservices. Cette compétence fournit un guide expert pour le développement Go 1.21+ avec des modèles idiomatiques pour les systèmes à haute performance.
Prend en charge: Claude Codex Code(CC)
1
Télécharger le ZIP du skill
2
Importer dans Claude
Allez dans Paramètres → Capacités → Skills → Importer un skill
3
Activez et commencez à utiliser
Tester
Utilisation de "golang-pro". Créer un pool de workers concurrent avec 5 workers
Résultat attendu:
- Implémentation de code Go avec la struct WorkerPool
- Distribution des tâches basée sur les canaux
- Arrêt gracieux avec annulation du contexte
- Synchronisation WaitGroup pour la complétion des workers
Utilisation de "golang-pro". Écrire une fonction générique Map
Résultat attendu:
- Signature de fonction: func Map[T, U any](slice []T, fn func(T) U) []U
- Implémentation générique type-safe
- Exemple d'utilisation avec des types int et string
- Considérations de performance
Utilisation de "golang-pro". Concevoir une interface de stockage suivant les idiomes Go
Résultat attendu:
- Définitions d'interfaces petites et centrées
- Pattern accepter les interfaces, retourner les structs
- Exemples de composition io.Reader/Writer
- Implémentation concrète avec tests
Audit de sécurité
Risque faiblev1 • 2/7/2026
Documentation skill with legitimate Go programming patterns. All 195 static findings are false positives triggered by code examples in markdown files. No malicious intent detected.
6
Fichiers analysés
2,221
Lignes analysées
10
résultats
1
Total des audits
Problèmes à risque moyen (5)
SKILL.md:47-51references/concurrency.md:5-285references/generics.md:5-441references/interfaces.md:5-374references/project-structure.md:5-476references/testing.md:5-450
Documentation Code Examples Detected as Shell Commands
Static analyzer flagged shell command syntax in markdown documentation as 'Ruby/shell backtick execution'. These are legitimate Go build commands and tooling examples (e.g., go mod init, go build) within code blocks, not executable malicious code.
references/concurrency.md:8-13references/interfaces.md:79-82references/project-structure.md:135-429references/testing.md:339-380
Dynamic Import Patterns in Documentation
Static analyzer detected 'Dynamic import() expression' patterns in documentation files. These are TypeScript/JavaScript code examples within markdown documentation, not actual executable code.
Network Patterns in Documentation
Static analyzer detected hardcoded IP addresses and network patterns. These are network configuration examples in documentation, not actual network code.
Filesystem Patterns in Documentation
Static analyzer detected path traversal sequences and filesystem access patterns. These are file path examples and project structure documentation, not actual path traversal exploits.
Environment Access Patterns in Documentation
Static analyzer detected database connection string patterns. These are configuration examples showing best practices for environment-based configuration.
Facteurs de risque
⚡ Contient des scripts
Aucun emplacement spécifique enregistré
⚙️ Commandes externes
Aucun emplacement spécifique enregistré
🌐 Accès réseau
Aucun emplacement spécifique enregistré
📁 Accès au système de fichiers
Aucun emplacement spécifique enregistré
🔑 Variables d’environnement
Aucun emplacement spécifique enregistré
Audité par: claude
Score de qualité
45
Architecture
100
Maintenabilité
87
Contenu
50
Communauté
65
Sécurité
91
Conformité aux spécifications
Ce que vous pouvez construire
Création de services API concurrents
Concevoir et implémenter des API Go à haute performance en utilisant goroutines et canaux pour le traitement concurrent des requêtes avec une propagation de contexte appropriée.
Développement de microservices gRPC
Créer des microservices type-safe en utilisant Protocol Buffers et gRPC avec un design d'interface approprié et des modèles de gestion d'erreurs.
Optimisation des performances du code Go
Refactoriser le code Go existant pour de meilleures performances en utilisant les benchmarks, l'analyse pprof et les modèles idiomatiques.
Essayez ces prompts
Implémentation Go de base
Écrivez une fonction Go qui implémente [description de la fonctionnalité]. Utilisez des modèles idiomatiques Go 1.21+ avec une gestion appropriée des erreurs et du contexte.
Traitement concurrent
Créez un pool de workers en Go qui traite les éléments de manière concurrente. Incluez l'arrêt gracieux, la synchronisation appropriée avec sync.WaitGroup et la gestion de l'annulation du contexte.
Fonctions utilitaires génériques
Écrivez une fonction générique Go avec des paramètres de type qui [description de la fonction générique]. Utilisez des contraintes appropriées du paquet constraints ou des interfaces personnalisées.
Microservice complet
Concevez un microservice gRPC complet avec [nom du service]. Incluez les définitions protobuf, l'implémentation du serveur, les contrats d'interface et des tests table-driven avec une couverture de 80%+.
Bonnes pratiques
- Utiliser goroutines avec une gestion claire du cycle de vie et une propagation de contexte pour prévenir les fuites de goroutine
- Écrire des tests table-driven avec des sous-tests pour une couverture complète et une sortie de défaillance lisible
- Appliquer le pattern 'accepter les interfaces, retourner les structs' pour un code flexible et testable
Éviter
- Éviter de créer des goroutines sans synchronisation par canal ou sans gestion de l'annulation du contexte
- Ne pas utiliser la réflexion pour les assertions de type lorsque les type switches ou les génériques suffisent
- Ne jamais coder en dur les valeurs de configuration; utiliser des options fonctionnelles ou des variables d'environnement à la place
Foire aux questions
Quelle version de Go est prise en charge par cette compétence ?
Cette compétence se concentre sur les modèles Go 1.21+ incluant les génériques (introduits en 1.18), les fonctionnalités de concurrence améliorées et les outils modernes.
Comment cette compétence gère-t-elle les modèles de concurrence ?
Elle fournit des pools de workers, une synchronisation basée sur les canaux, une propagation de contexte et une gestion appropriée du cycle de vie en utilisant des primitives sync.
Cette compétence génère-t-elle du code de test ?
Oui, elle génère des tests table-driven avec des sous-tests, des benchmarks et intègre des indicateurs de détecteur de concurrence pour le code concurrent.
Cette compétence peut-elle aider avec le développement gRPC ?
Oui, elle fournit des définitions protobuf, des implémentations de serveur/client gRPC et une gestion appropriée des erreurs pour les microservices.
Comment les génériques sont-ils couverts dans cette compétence ?
La compétence inclut des paramètres de type, des contraintes (intégrées et personnalisées), des fonctions génériques et des définitions de types génériques avec des exemples pratiques.
Cette compétence optimise-t-elle le code Go existant ?
Elle fournit des conseils sur le profilage avec pprof, l'écriture de benchmarks, l'élimination des allocations et l'application de modèles idiomatiques Go pour les performances.