Claude peut utiliser un outil d’éditeur de texte défini par Anthropic pour afficher et modifier des fichiers texte, vous aidant à déboguer, corriger et améliorer votre code ou d’autres documents texte. Cela permet à Claude d’interagir directement avec vos fichiers, en fournissant une assistance pratique plutôt que de simplement suggérer des modifications.

Compatibilité des modèles

ModèleVersion de l’outil
Modèles Claude 4.xtext_editor_20250728
Claude Sonnet 3.7 (déprécié)text_editor_20250124
L’outil text_editor_20250728 pour les modèles Claude 4 n’inclut pas la commande undo_edit. Si vous avez besoin de cette fonctionnalité, vous devrez utiliser Claude Sonnet 3.7 (déprécié).
Les versions antérieures de l’outil ne sont pas garanties d’être rétrocompatibles avec les modèles plus récents. Utilisez toujours la version de l’outil qui correspond à votre version de modèle.

Quand utiliser l’outil d’éditeur de texte

Voici quelques exemples de quand utiliser l’outil d’éditeur de texte :
  • Débogage de code : Demandez à Claude d’identifier et de corriger les bogues dans votre code, des erreurs de syntaxe aux problèmes de logique.
  • Refactorisation de code : Laissez Claude améliorer la structure, la lisibilité et les performances de votre code grâce à des modifications ciblées.
  • Génération de documentation : Demandez à Claude d’ajouter des docstrings, des commentaires ou des fichiers README à votre base de code.
  • Création de tests : Demandez à Claude de créer des tests unitaires pour votre code en fonction de sa compréhension de l’implémentation.

Utiliser l’outil d’éditeur de texte

Fournissez l’outil d’éditeur de texte (nommé str_replace_based_edit_tool) à Claude en utilisant l’API Messages.Vous pouvez éventuellement spécifier un paramètre max_characters pour contrôler la troncature lors de la visualisation de fichiers volumineux.
max_characters est uniquement compatible avec text_editor_20250728 et les versions ultérieures de l’outil d’éditeur de texte.
curl https://api.anthropic.com/v1/messages \
  -H "content-type: application/json" \
  -H "x-api-key: $ANTHROPIC_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -d '{
    "model": "claude-sonnet-4-5",
    "max_tokens": 1024,
    "tools": [
      {
        "type": "text_editor_20250728",
        "name": "str_replace_based_edit_tool",
        "max_characters": 10000
      }
    ],
    "messages": [
      {
        "role": "user",
        "content": "There'\''s a syntax error in my primes.py file. Can you help me fix it?"
      }
    ]
  }'
L’outil d’éditeur de texte peut être utilisé de la manière suivante :
1

Fournir à Claude l'outil d'éditeur de texte et une invite utilisateur

  • Incluez l’outil d’éditeur de texte dans votre demande d’API
  • Fournissez une invite utilisateur qui peut nécessiter d’examiner ou de modifier des fichiers, comme « Pouvez-vous corriger l’erreur de syntaxe dans mon code ? »
2

Claude utilise l'outil pour examiner les fichiers ou répertoires

  • Claude évalue ce qu’il doit examiner et utilise la commande view pour examiner le contenu des fichiers ou lister le contenu des répertoires
  • La réponse de l’API contiendra un bloc de contenu tool_use avec la commande view
3

Exécuter la commande view et retourner les résultats

  • Extrayez le chemin du fichier ou du répertoire de la demande d’utilisation d’outil de Claude
  • Lisez le contenu du fichier ou listez le contenu du répertoire
  • Si un paramètre max_characters a été spécifié dans la configuration de l’outil, tronquez le contenu du fichier à cette longueur
  • Retournez les résultats à Claude en continuant la conversation avec un nouveau message user contenant un bloc de contenu tool_result
4

Claude utilise l'outil pour modifier les fichiers

  • Après avoir examiné le fichier ou le répertoire, Claude peut utiliser une commande telle que str_replace pour apporter des modifications ou insert pour ajouter du texte à un numéro de ligne spécifique.
  • Si Claude utilise la commande str_replace, Claude construit une demande d’utilisation d’outil correctement formatée avec l’ancien texte et le nouveau texte pour le remplacer
5

Exécuter la modification et retourner les résultats

  • Extrayez le chemin du fichier, l’ancien texte et le nouveau texte de la demande d’utilisation d’outil de Claude
  • Effectuez le remplacement de texte dans le fichier
  • Retournez les résultats à Claude
6

Claude fournit son analyse et son explication

  • Après avoir examiné et possiblement modifié les fichiers, Claude fournit une explication complète de ce qu’il a trouvé et des modifications qu’il a apportées

Commandes de l’outil d’éditeur de texte

L’outil d’éditeur de texte prend en charge plusieurs commandes pour afficher et modifier des fichiers :

view

La commande view permet à Claude d’examiner le contenu d’un fichier ou de lister le contenu d’un répertoire. Elle peut lire l’intégralité du fichier ou une plage de lignes spécifique. Paramètres :
  • command : Doit être « view »
  • path : Le chemin du fichier ou du répertoire à afficher
  • view_range (optionnel) : Un tableau de deux entiers spécifiant les numéros de ligne de début et de fin à afficher. Les numéros de ligne sont indexés à partir de 1, et -1 pour la ligne de fin signifie lire jusqu’à la fin du fichier. Ce paramètre s’applique uniquement lors de l’affichage de fichiers, pas de répertoires.
// Exemple pour afficher un fichier
{
  "type": "tool_use",
  "id": "toolu_01A09q90qw90lq917835lq9",
  "name": "str_replace_editor",
  "input": {
    "command": "view",
    "path": "primes.py"
  }
}

// Exemple pour afficher un répertoire
{
  "type": "tool_use",
  "id": "toolu_02B19r91rw91mr917835mr9",
  "name": "str_replace_editor",
  "input": {
    "command": "view",
    "path": "src/"
  }
}

str_replace

La commande str_replace permet à Claude de remplacer une chaîne spécifique dans un fichier par une nouvelle chaîne. Ceci est utilisé pour effectuer des modifications précises. Paramètres :
  • command : Doit être « str_replace »
  • path : Le chemin du fichier à modifier
  • old_str : Le texte à remplacer (doit correspondre exactement, y compris les espaces et l’indentation)
  • new_str : Le nouveau texte à insérer à la place de l’ancien texte
{
  "type": "tool_use",
  "id": "toolu_01A09q90qw90lq917835lq9",
  "name": "str_replace_editor",
  "input": {
    "command": "str_replace",
    "path": "primes.py",
    "old_str": "for num in range(2, limit + 1)",
    "new_str": "for num in range(2, limit + 1):"
  }
}

create

La commande create permet à Claude de créer un nouveau fichier avec le contenu spécifié. Paramètres :
  • command : Doit être « create »
  • path : Le chemin où le nouveau fichier doit être créé
  • file_text : Le contenu à écrire dans le nouveau fichier
{
  "type": "tool_use",
  "id": "toolu_01A09q90qw90lq917835lq9",
  "name": "str_replace_editor",
  "input": {
    "command": "create",
    "path": "test_primes.py",
    "file_text": "import unittest\nimport primes\n\nclass TestPrimes(unittest.TestCase):\n    def test_is_prime(self):\n        self.assertTrue(primes.is_prime(2))\n        self.assertTrue(primes.is_prime(3))\n        self.assertFalse(primes.is_prime(4))\n\nif __name__ == '__main__':\n    unittest.main()"
  }
}

insert

La commande insert permet à Claude d’insérer du texte à un emplacement spécifique dans un fichier. Paramètres :
  • command : Doit être « insert »
  • path : Le chemin du fichier à modifier
  • insert_line : Le numéro de ligne après lequel insérer le texte (0 pour le début du fichier)
  • new_str : Le texte à insérer
{
  "type": "tool_use",
  "id": "toolu_01A09q90qw90lq917835lq9",
  "name": "str_replace_editor",
  "input": {
    "command": "insert",
    "path": "primes.py",
    "insert_line": 0,
    "new_str": "\"\"\"Module for working with prime numbers.\n\nThis module provides functions to check if a number is prime\nand to generate a list of prime numbers up to a given limit.\n\"\"\"\n"
  }
}

undo_edit

La commande undo_edit permet à Claude d’annuler la dernière modification apportée à un fichier.
Cette commande n’est disponible que dans Claude Sonnet 3.7 (déprécié). Elle n’est pas prise en charge dans les modèles Claude 4 utilisant le text_editor_20250728.
Paramètres :
  • command : Doit être « undo_edit »
  • path : Le chemin du fichier dont la dernière modification doit être annulée
{
  "type": "tool_use",
  "id": "toolu_01A09q90qw90lq917835lq9",
  "name": "str_replace_editor",
  "input": {
    "command": "undo_edit",
    "path": "primes.py"
  }
}

Exemple : Corriger une erreur de syntaxe avec l’outil d’éditeur de texte

Cet exemple montre comment les modèles Claude 4 utilisent l’outil d’éditeur de texte pour corriger une erreur de syntaxe dans un fichier Python.Tout d’abord, votre application fournit à Claude l’outil d’éditeur de texte et une invite pour corriger une erreur de syntaxe :
curl https://api.anthropic.com/v1/messages \
  -H "content-type: application/json" \
  -H "x-api-key: $ANTHROPIC_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -d '{
    "model": "claude-sonnet-4-5",
    "max_tokens": 1024,
    "tools": [
      {
        "type": "text_editor_20250728",
        "name": "str_replace_based_edit_tool"
      }
    ],
    "messages": [
      {
        "role": "user",
        "content": "There'\''s a syntax error in my primes.py file. Can you help me fix it?"
      }
    ]
  }'
Claude utilisera d’abord l’outil d’éditeur de texte pour afficher le fichier :
{
  "id": "msg_01XAbCDeFgHiJkLmNoPQrStU",
  "model": "claude-sonnet-4-5",
  "stop_reason": "tool_use",
  "role": "assistant",
  "content": [
    {
      "type": "text",
      "text": "I'll help you fix the syntax error in your primes.py file. First, let me take a look at the file to identify the issue."
    },
    {
      "type": "tool_use",
      "id": "toolu_01AbCdEfGhIjKlMnOpQrStU",
      "name": "str_replace_based_edit_tool",
      "input": {
        "command": "view",
        "path": "primes.py"
      }
    }
  ]
}
Votre application doit ensuite lire le fichier et retourner son contenu à Claude :
curl https://api.anthropic.com/v1/messages \
  -H "content-type: application/json" \
  -H "x-api-key: $ANTHROPIC_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -d '{
    "model": "claude-sonnet-4-5",
    "max_tokens": 1024,
    "tools": [
      {
        "type": "text_editor_20250728",
        "name": "str_replace_based_edit_tool"
      }
    ],
    "messages": [
      {
        "role": "user",
        "content": "There'\''s a syntax error in my primes.py file. Can you help me fix it?"
      },
      {
            "role": "assistant",
            "content": [
                {
                    "type": "text",
                    "text": "I'\''ll help you fix the syntax error in your primes.py file. First, let me take a look at the file to identify the issue."
                },
                {
                    "type": "tool_use",
                    "id": "toolu_01AbCdEfGhIjKlMnOpQrStU",
                    "name": "str_replace_based_edit_tool",
                    "input": {
                        "command": "view",
                        "path": "primes.py"
                    }
                }
            ]
        },
        {
            "role": "user",
            "content": [
                {
                    "type": "tool_result",
                    "tool_use_id": "toolu_01AbCdEfGhIjKlMnOpQrStU",
                    "content": "1: def is_prime(n):\n2:     \"\"\"Check if a number is prime.\"\"\"\n3:     if n <= 1:\n4:         return False\n5:     if n <= 3:\n6:         return True\n7:     if n % 2 == 0 or n % 3 == 0:\n8:         return False\n9:     i = 5\n10:     while i * i <= n:\n11:         if n % i == 0 or n % (i + 2) == 0:\n12:             return False\n13:         i += 6\n14:     return True\n15: \n16: def get_primes(limit):\n17:     \"\"\"Generate a list of prime numbers up to the given limit.\"\"\"\n18:     primes = []\n19:     for num in range(2, limit + 1)\n20:         if is_prime(num):\n21:             primes.append(num)\n22:     return primes\n23: \n24: def main():\n25:     \"\"\"Main function to demonstrate prime number generation.\"\"\"\n26:     limit = 100\n27:     prime_list = get_primes(limit)\n28:     print(f\"Prime numbers up to {limit}:\")\n29:     print(prime_list)\n30:     print(f\"Found {len(prime_list)} prime numbers.\")\n31: \n32: if __name__ == \"__main__\":\n33:     main()"
                }
            ]
        }
    ]
  }'
Numéros de ligneDans l’exemple ci-dessus, le résultat de l’outil view inclut le contenu du fichier avec les numéros de ligne ajoutés au début de chaque ligne (par exemple, « 1: def is_prime(n): »). Les numéros de ligne ne sont pas obligatoires, mais ils sont essentiels pour utiliser avec succès le paramètre view_range pour examiner des sections spécifiques de fichiers et le paramètre insert_line pour ajouter du contenu à des emplacements précis.
Claude identifiera l’erreur de syntaxe et utilisera la commande str_replace pour la corriger :
{
  "id": "msg_01VwXyZAbCdEfGhIjKlMnO",
  "model": "claude-sonnet-4-5",
  "stop_reason": "tool_use",
  "role": "assistant",
  "content": [
    {
      "type": "text",
      "text": "I found the syntax error in your primes.py file. In the `get_primes` function, there is a missing colon (:) at the end of the for loop line. Let me fix that for you."
    },
    {
      "type": "tool_use",
      "id": "toolu_01PqRsTuVwXyZAbCdEfGh",
      "name": "str_replace_based_edit_tool",
      "input": {
        "command": "str_replace",
        "path": "primes.py",
        "old_str": "    for num in range(2, limit + 1)",
        "new_str": "    for num in range(2, limit + 1):"
      }
    }
  ]
}
Votre application doit ensuite effectuer la modification et retourner le résultat :
response = client.messages.create(
    model="claude-sonnet-4-5",
    max_tokens=1024,
    tools=[
        {
            "type": "text_editor_20250728",
            "name": "str_replace_based_edit_tool"
        }
    ],
    messages=[
        # Previous messages...
        {
            "role": "assistant",
            "content": [
                {
                    "type": "text",
                    "text": "I found the syntax error in your primes.py file. In the `get_primes` function, there is a missing colon (:) at the end of the for loop line. Let me fix that for you."
                },
                {
                    "type": "tool_use",
                    "id": "toolu_01PqRsTuVwXyZAbCdEfGh",
                    "name": "str_replace_based_edit_tool",
                    "input": {
                        "command": "str_replace",
                        "path": "primes.py",
                        "old_str": "    for num in range(2, limit + 1)",
                        "new_str": "    for num in range(2, limit + 1):"
                    }
                }
            ]
        },
        {
            "role": "user",
            "content": [
                {
                    "type": "tool_result",
                    "tool_use_id": "toolu_01PqRsTuVwXyZAbCdEfGh",
                    "content": "Successfully replaced text at exactly one location."
                }
            ]
        }
    ]
)
Enfin, Claude fournira une explication complète de la correction :
{
  "id": "msg_01IjKlMnOpQrStUvWxYzAb",
  "model": "claude-sonnet-4-5",
  "stop_reason": "end_turn",
  "role": "assistant",
  "content": [
    {
      "type": "text",
      "text": "I've fixed the syntax error in your primes.py file. The issue was in the `get_primes` function at line 19. There was a missing colon (:) at the end of the for loop line.\n\nHere's what I changed:\n\nFrom:\n```python\nfor num in range(2, limit + 1)\n```\n\nTo:\n```python\nfor num in range(2, limit + 1):\n```\n\nIn Python, a colon is required at the end of statements that start a new code block, such as for loops, if statements, function definitions, etc. Without the colon, Python raises a syntax error because it doesn't know where the code block begins.\n\nYour code should now run correctly. The function will properly generate a list of prime numbers up to the specified limit."
    }
  ]
}

Implémenter l’outil d’éditeur de texte

L’outil d’éditeur de texte est implémenté en tant qu’outil sans schéma. Lors de l’utilisation de cet outil, vous n’avez pas besoin de fournir un schéma d’entrée comme avec d’autres outils ; le schéma est intégré au modèle et ne peut pas être modifié. Le type d’outil dépend de la version du modèle :
  • Claude 4 : type: "text_editor_20250728"
  • Claude Sonnet 3.7 : type: "text_editor_20250124"
1

Initialiser votre implémentation d'éditeur

Créez des fonctions d’aide pour gérer les opérations de fichiers comme la lecture, l’écriture et la modification de fichiers. Envisagez d’implémenter une fonctionnalité de sauvegarde pour récupérer les erreurs.
2

Gérer les appels d'outils d'éditeur

Créez une fonction qui traite les appels d’outils de Claude en fonction du type de commande :
def handle_editor_tool(tool_call, model_version):
    input_params = tool_call.input
    command = input_params.get('command', '')
    file_path = input_params.get('path', '')
    
    if command == 'view':
        # Read and return file contents
        pass
    elif command == 'str_replace':
        # Replace text in file
        pass
    elif command == 'create':
        # Create new file
        pass
    elif command == 'insert':
        # Insert text at location
        pass
    elif command == 'undo_edit':
        # Check if it's a Claude 4 model
        if 'str_replace_based_edit_tool' in model_version:
            return {"error": "undo_edit command is not supported in Claude 4"}
        # Restore from backup for Claude 3.7
        pass
3

Implémenter les mesures de sécurité

Ajoutez des vérifications de validation et de sécurité :
  • Validez les chemins de fichiers pour prévenir la traversée de répertoires
  • Créez des sauvegardes avant d’apporter des modifications
  • Gérez les erreurs correctement
  • Implémentez des vérifications de permissions
4

Traiter les réponses de Claude

Extrayez et gérez les appels d’outils des réponses de Claude :
# Process tool use in Claude's response
for content in response.content:
    if content.type == "tool_use":
        # Execute the tool based on command
        result = handle_editor_tool(content)
        
        # Return result to Claude
        tool_result = {
            "type": "tool_result",
            "tool_use_id": content.id,
            "content": result
        }
Lors de l’implémentation de l’outil d’éditeur de texte, gardez à l’esprit :
  1. Sécurité : L’outil a accès à votre système de fichiers local, donc implémentez des mesures de sécurité appropriées.
  2. Sauvegarde : Créez toujours des sauvegardes avant de permettre les modifications de fichiers importants.
  3. Validation : Validez toutes les entrées pour prévenir les modifications involontaires.
  4. Correspondance unique : Assurez-vous que les remplacements correspondent exactement à un seul emplacement pour éviter les modifications involontaires.

Gérer les erreurs

Lors de l’utilisation de l’outil d’éditeur de texte, diverses erreurs peuvent survenir. Voici des conseils sur la façon de les gérer :
Si Claude essaie d’afficher ou de modifier un fichier qui n’existe pas, retournez un message d’erreur approprié dans le tool_result :
{
  "role": "user",
  "content": [
    {
      "type": "tool_result",
      "tool_use_id": "toolu_01A09q90qw90lq917835lq9",
      "content": "Error: File not found",
      "is_error": true
    }
  ]
}
Si la commande str_replace de Claude correspond à plusieurs emplacements dans le fichier, retournez un message d’erreur approprié :
{
  "role": "user",
  "content": [
    {
      "type": "tool_result",
      "tool_use_id": "toolu_01A09q90qw90lq917835lq9",
      "content": "Error: Found 3 matches for replacement text. Please provide more context to make a unique match.",
      "is_error": true
    }
  ]
}
Si la commande str_replace de Claude ne correspond à aucun texte dans le fichier, retournez un message d’erreur approprié :
{
  "role": "user",
  "content": [
    {
      "type": "tool_result",
      "tool_use_id": "toolu_01A09q90qw90lq917835lq9",
      "content": "Error: No match found for replacement. Please check your text and try again.",
      "is_error": true
    }
  ]
}
S’il y a des problèmes de permission avec la création, la lecture ou la modification de fichiers, retournez un message d’erreur approprié :
{
  "role": "user",
  "content": [
    {
      "type": "tool_result",
      "tool_use_id": "toolu_01A09q90qw90lq917835lq9",
      "content": "Error: Permission denied. Cannot write to file.",
      "is_error": true
    }
  ]
}

Suivre les meilleures pratiques de mise en œuvre

Lorsque vous demandez à Claude de corriger ou de modifier du code, soyez spécifique sur les fichiers qui doivent être examinés ou les problèmes qui doivent être résolus. Un contexte clair aide Claude à identifier les bons fichiers et à apporter les modifications appropriées.Invite moins utile : « Pouvez-vous corriger mon code ? »Meilleure invite : « Il y a une erreur de syntaxe dans mon fichier primes.py qui l’empêche de s’exécuter. Pouvez-vous la corriger ? »
Spécifiez clairement les chemins de fichiers si nécessaire, surtout si vous travaillez avec plusieurs fichiers ou des fichiers dans différents répertoires.Invite moins utile : « Examinez mon fichier d’aide »Meilleure invite : « Pouvez-vous vérifier mon fichier utils/helpers.py pour les problèmes de performance ? »
Implémentez un système de sauvegarde dans votre application qui crée des copies de fichiers avant de permettre à Claude de les modifier, en particulier pour le code important ou de production.
def backup_file(file_path):
    """Create a backup of a file before editing."""
    backup_path = f"{file_path}.backup"
    if os.path.exists(file_path):
        with open(file_path, 'r') as src, open(backup_path, 'w') as dst:
            dst.write(src.read())
La commande str_replace nécessite une correspondance exacte du texte à remplacer. Votre application doit s’assurer qu’il y a exactement une correspondance pour l’ancien texte ou fournir des messages d’erreur appropriés.
def safe_replace(file_path, old_text, new_text):
    """Replace text only if there's exactly one match."""
    with open(file_path, 'r') as f:
        content = f.read()
    
    count = content.count(old_text)
    if count == 0:
        return "Error: No match found"
    elif count > 1:
        return f"Error: Found {count} matches"
    else:
        new_content = content.replace(old_text, new_text)
        with open(file_path, 'w') as f:
            f.write(new_content)
        return "Successfully replaced text"
Après que Claude ait apporté des modifications à un fichier, vérifiez les modifications en exécutant des tests ou en vérifiant que le code fonctionne toujours comme prévu.
def verify_changes(file_path):
    """Run tests or checks after making changes."""
    try:
        # For Python files, check for syntax errors
        if file_path.endswith('.py'):
            import ast
            with open(file_path, 'r') as f:
                ast.parse(f.read())
            return "Syntax check passed"
    except Exception as e:
        return f"Verification failed: {str(e)}"

Tarification et utilisation des tokens

The text editor tool uses the same pricing structure as other tools used with Claude. It follows the standard input and output token pricing based on the Claude model you’re using. In addition to the base tokens, the following additional input tokens are needed for the text editor tool:
ToolAdditional input tokens
text_editor_20250429 (Claude 4.x)700 tokens
text_editor_20250124 (Claude Sonnet 3.7 (deprecated))700 tokens
Pour plus d’informations détaillées sur la tarification des outils, consultez Tarification de l’utilisation des outils.

Intégrer l’outil d’éditeur de texte avec d’autres outils

L’outil d’éditeur de texte peut être utilisé aux côtés d’autres outils Claude. Lors de la combinaison d’outils, assurez-vous de :
  • Faire correspondre la version de l’outil avec le modèle que vous utilisez
  • Tenir compte de l’utilisation supplémentaire de tokens pour tous les outils inclus dans votre demande

Journal des modifications

DateVersionModifications
28 juillet 2025text_editor_20250728Publication d’un outil d’éditeur de texte mis à jour qui corrige certains problèmes et ajoute un paramètre max_characters optionnel. Il est par ailleurs identique à text_editor_20250429.
29 avril 2025text_editor_20250429Publication de l’outil d’éditeur de texte pour Claude 4. Cette version supprime la commande undo_edit mais maintient toutes les autres capacités. Le nom de l’outil a été mis à jour pour refléter son architecture basée sur str_replace.
13 mars 2025text_editor_20250124Introduction de la documentation autonome de l’outil d’éditeur de texte. Cette version est optimisée pour Claude Sonnet 3.7 mais a des capacités identiques à la version précédente.
22 octobre 2024text_editor_20241022Publication initiale de l’outil d’éditeur de texte avec Claude Sonnet 3.5 (retiré). Fournit des capacités pour afficher, créer et modifier des fichiers via les commandes view, create, str_replace, insert et undo_edit.

Prochaines étapes

Voici quelques idées sur la façon d’utiliser l’outil d’éditeur de texte de manière plus pratique et puissante :
  • Intégrer à votre flux de travail de développement : Intégrez l’outil d’éditeur de texte dans vos outils de développement ou IDE
  • Créer un système d’examen de code : Demandez à Claude d’examiner votre code et d’apporter des améliorations
  • Construire un assistant de débogage : Créez un système où Claude peut vous aider à diagnostiquer et corriger les problèmes dans votre code
  • Implémenter la conversion de format de fichier : Laissez Claude vous aider à convertir des fichiers d’un format à un autre
  • Automatiser la documentation : Configurez des flux de travail pour que Claude documente automatiquement votre code
Au fur et à mesure que vous construisez des applications avec l’outil d’éditeur de texte, nous sommes impatients de voir comment vous exploitez les capacités de Claude pour améliorer votre flux de travail de développement et votre productivité.