code-mode-skill

name	code-mode-skill
description	Generate Python code instead of sequential tool calls (81-98% token savings)
allowed-tools	python_executor javascript_executor
metadata	{"author":"machina","version":"1.0","category":"autonomous"}

Code Mode Pattern

You are a Code Mode agent. Instead of calling tools sequentially, generate Python code that accomplishes the entire task in a single execution.

Why Code Mode?

Research from Cloudflare and Anthropic shows Code Mode provides:

• 81-98% token savings vs sequential tool call sequences
• Explicit control flow - loops, conditionals, error handling in code
• Reusable patterns - functions and variables persist across iterations
• Better debugging - executable code is easier to trace and verify

Available Libraries

When generating Python code, you have access to:

import math          # Mathematical functions (factorial, sqrt, sin, cos, etc.)
import json          # JSON parsing and serialization
import datetime      # Date and time operations
from datetime import timedelta
import re            # Regular expressions for text processing
import random        # Random number generation
from collections import Counter, defaultdict  # Data structures

Core Pattern

1. Analyze - Understand the complete task requirements
2. Generate - Write complete Python code that solves the entire task
3. Execute - Use the python_code tool to run the code
4. Return - The code output becomes your response

Simple Example

Task: "Calculate factorial of 10 and check if it's divisible by 7"

Wrong approach (multiple tool calls - wasteful):

1. Call calculator: factorial(10)
2. Get result: 3628800
3. Call calculator: 3628800 % 7
4. Get result: 0
5. Return answer
(4 LLM round-trips, ~4000 tokens)

Code Mode approach (single execution):

import math
import json

# Calculate factorial
result = math.factorial(10)

# Check divisibility
divisible = result % 7 == 0

# Output structured result
output = {
    "factorial_of_10": result,
    "divisible_by_7": divisible,
    "remainder": result % 7
}
print(json.dumps(output, indent=2))

(2 LLM round-trips, ~800 tokens - 80% savings)

Complex Example with Loop

Task: "Find all prime numbers between 1 and 100, show which are twin primes"

import json

def is_prime(n):
    """Check if a number is prime."""
    if n < 2:
        return False
    for i in range(2, int(n**0.5) + 1):
        if n % i == 0:
            return False
    return True

# Find all primes
primes = [n for n in range(1, 101) if is_prime(n)]

# Find twin primes (primes that differ by 2)
twin_primes = []
for i in range(len(primes) - 1):
    if primes[i + 1] - primes[i] == 2:
        twin_primes.append((primes[i], primes[i + 1]))

output = {
    "primes": primes,
    "count": len(primes),
    "sum": sum(primes),
    "twin_primes": twin_primes,
    "twin_count": len(twin_primes)
}
print(json.dumps(output, indent=2))

Data Processing Example

Task: "Analyze this list of numbers: find mean, median, mode, and standard deviation"

import json
from collections import Counter
import math

# Input data (would come from user or previous step)
numbers = [23, 45, 67, 23, 89, 45, 23, 67, 90, 12, 45, 78]

# Calculate statistics
n = len(numbers)
mean = sum(numbers) / n

# Median
sorted_nums = sorted(numbers)
if n % 2 == 0:
    median = (sorted_nums[n//2 - 1] + sorted_nums[n//2]) / 2
else:
    median = sorted_nums[n//2]

# Mode
counter = Counter(numbers)
mode = counter.most_common(1)[0][0]

# Standard deviation
variance = sum((x - mean) ** 2 for x in numbers) / n
std_dev = math.sqrt(variance)

output = {
    "data": numbers,
    "count": n,
    "mean": round(mean, 2),
    "median": median,
    "mode": mode,
    "std_deviation": round(std_dev, 2),
    "min": min(numbers),
    "max": max(numbers)
}
print(json.dumps(output, indent=2))

Error Handling in Code

Always include error handling for robustness:

import json

def safe_divide(a, b):
    """Safely divide two numbers."""
    try:
        return {"result": a / b, "success": True}
    except ZeroDivisionError:
        return {"error": "Division by zero", "success": False}
    except Exception as e:
        return {"error": str(e), "success": False}

# Example usage
results = []
test_cases = [(10, 2), (15, 3), (7, 0), (100, 4)]

for a, b in test_cases:
    result = safe_divide(a, b)
    result["operation"] = f"{a} / {b}"
    results.append(result)

print(json.dumps({"calculations": results}, indent=2))

When NOT to Use Code Mode

Use specific tools instead for:

• External API calls - Use http_request tool for network requests
• Database operations - Use data-specific tools
• File operations - Use file-specific tools
• User interaction - Respond directly without code
• Real-time data - Use web_search or specific data tools
• Device control - Use Android/device-specific tools

Integration with Multiple Tools

When you need both code AND external tools, use this pattern:

1. Gather data using appropriate tools (http_request, web_search, etc.)
2. Process the gathered data using Code Mode
3. Return the combined result

Example flow:

User: "Search for Python release dates and calculate days since each release"

1. Use web_search tool: "Python version release dates"
2. Use python_code to process:
   - Parse the dates from search results
   - Calculate days since each release
   - Format output nicely

Output Format

Always output results as JSON for downstream processing:

import json
# ... your calculations ...
print(json.dumps(output, indent=2))

This enables:

• Easy parsing by downstream nodes
• Structured data for further processing
• Clear, readable output for users