Complex code is just simple patterns stacked on top of each other. In this tutorial, we will build a Code Explainer agent that takes a confusing function and returns a line-by-line breakdown, a concept list, and a simplified rewrite. We will run it on Oxlo.ai so you pay a flat rate per request, which makes it cheap to drop in large files for analysis.
What you'll need
- Python 3.10 or newer
- The OpenAI SDK:
pip install openai - An Oxlo.ai API key from https://portal.oxlo.ai
Oxlo.ai is fully OpenAI SDK compatible, so the only change is the base URL.
Step 1: Configure the Oxlo.ai client
We start by importing the SDK and pointing it at Oxlo.ai. I use llama-3.3-70b as the default because it follows structured instructions precisely.
from openai import OpenAI
import os
client = OpenAI(
base_url="https://api.oxlo.ai/v1",
api_key=os.getenv("OXLO_API_KEY", "YOUR_OXLO_API_KEY")
)
print("Client ready for Oxlo.ai")
Step 2: Define the system prompt
The system prompt is the agent's instruction manual. It forces four consistent sections so beginners always know what to expect.
SYSTEM_PROMPT = """You are a patient senior engineer teaching a junior developer.
When you receive code, return exactly these sections:
1. Summary: one sentence describing what the code does.
2. Line-by-line: break the code into logical chunks and explain each.
3. Concepts: bullet list of programming concepts used.
4. Simplified rewrite: reproduce the logic using only basic Python constructs.
Use Markdown. Do not skip any section."""
Step 3: Build the explainer function
This wrapper sends the user code and the system prompt to the model. Because Oxlo.ai uses request-based pricing, you can paste a 200-line module and the cost stays the same as a one-liner.
def explain_code(code: str, model: str = "llama-3.3-70b") -> str:
response = client.chat.completions.create(
model=model,
messages=[
{"role": "system", "content": SYSTEM_PROMPT},
{"role": "user", "content": f"Explain this Python code:\n\n
```python\n{code}\n```
"},
],
temperature=0.2,
)
return response.choices[0].message.content
Step 4: Route complex snippets to a stronger model
When the input contains recursion, decorators, or many lines, I switch to kimi-k2.6 for deeper chain-of-thought reasoning. A simple heuristic keeps the routing transparent.
def route_and_explain(code: str) -> str:
markers = ["def ", "lambda", "yield", "@", "recursive"]
is_complex = any(m in code for m in markers) or code.count("\n") > 30
model = "kimi-k2.6" if is_complex else "llama-3.3-70b"
print(f"Routing to {model} ...")
return explain_code(code, model=model)
Step 5: Add an interactive CLI
A small stdin loop lets us paste code directly from the clipboard and immediately see the explanation.
import sys
if __name__ == "__main__":
print("Paste Python code. Press Ctrl+D (Unix) or Ctrl+Z then Enter (Windows) when done.")
user_input = sys.stdin.read()
if user_input.strip():
result = route_and_explain(user_input)
print("\n=== Explanation ===\n")
print(result)
Run it
I feed the agent a snippet that mixes closures, decorators, and recursion. This triggers the router to select Kimi K2.6.
TEST_CODE = '''
def memoize(f):
cache = {}
def wrapper(*args):
if args not in cache:
cache[args] = f(*args)
return cache[args]
return wrapper
@memoize
def fib(n):
if n < 2:
return n
return fib(n - 1) + fib(n - 2)
'''
output = route_and_explain(TEST_CODE)
print(output)
Example output:
Routing to kimi-k2.6 ...
=== Explanation ===
1. Summary
This code implements a memoization decorator to optimize a recursive Fibonacci function.
2. Line-by-line
- `def memoize(f):` defines a higher-order function that accepts another function `f`.
- `cache = {}` creates a dictionary to store previous results.
- `def wrapper(*args):` defines an inner function that intercepts calls to `f`.
- `if args not in cache:` checks whether we have already computed this input.
- `cache[args] = f(*args)` runs the original function and stores the result.
- `return cache[args]` returns the cached value.
- `return wrapper` hands back the enhanced function.
- `@memoize` applies the decorator to `fib`.
- `def fib(n):` is the recursive Fibonacci implementation.
- `if n < 2: return n` handles the base cases.
- `return fib(n - 1) + fib(n - 2)` recursively sums the two preceding numbers.
3. Concepts
- Closures
- Decorators
- Memoization / caching
- Recursion
- Higher-order functions
4. Simplified rewrite
```python
def fib_slow(n):
if n < 2:
return n
return fib_slow(n - 1) + fib_slow(n - 2)
```
Without memoization, this is the core logic. The decorator simply saves answers so we do not repeat work.
Next steps
Swap in deepseek-v3.2 for pure coding problems, or qwen-3-32b if you are working with multilingual comments. Because Oxlo.ai uses flat per-request pricing, you can paste entire modules into the context window without worrying about input token costs. See the exact tiers at https://oxlo.ai/pricing.
Two concrete upgrades: wire this into a VS Code extension using the same OpenAI client pattern, or add a second agent call that generates unit tests for the simplified rewrite.
Top comments (0)