How I Use Claude AI to Write, Review and Document Code Faster

After two decades building systems across banking, blockchain, and digital forensics, I've learned that the tools we choose define the speed and quality of what we ship. When Claude AI entered my workflow, something shifted. I stopped treating AI as a novelty and started treating it as a genuine engineering partner—one that reviews my Soroban smart contracts, drafts documentation nobody wants to write, and helps me reason through architecture decisions in real time.

Let me share exactly how I integrate Claude into my daily practice, with concrete examples from tokenization projects on Stellar.

Writing Code Faster Without Sacrificing Rigor

Speed without correctness is technical debt in disguise. My approach is to use Claude as a pair programmer that accelerates the tedious 70% so I can focus on the critical 30%.

A recent example: I was building a Soroban contract for a real-world asset tokenization pilot. Instead of hand-writing boilerplate for storage helpers, event emission, and access control, I described the domain model to Claude and iterated on the generated Rust. What normally takes me a full day of scaffolding took roughly two hours.

The key discipline—and I stress this to every team I lead as André Dias Moreira Prol—is that I never paste generated code blindly. I prompt with explicit constraints:

Generate a Soroban storage struct for a fractional
asset token. Requirements:
- Use instance storage for admin config
- Use persistent storage for balances
- Include TTL extension logic
- No unwrap() in production paths

That last constraint matters. In Soroban, a panic from `unwrap()` reverts the transaction and burns fees. By encoding my hard-won rules into prompts, I get output that already respects production realities. On my last three projects, this reduced initial review cycles by roughly 40%.

Code Review as a Conversation, Not a Gate

The most underrated use of Claude is adversarial review. I paste a function and ask a pointed question: "What are the three most likely security failures here, ranked by impact?"

For blockchain code, this catches issues that generic linters miss. In one audit-preparation phase, Claude flagged an integer overflow path in a reward-distribution loop that our static analysis tools had passed. In tokenization, a single overflow can mean minting phantom value—a catastrophic outcome when real assets back the token.

I also use it for reentrancy reasoning, authorization checks (`require_auth` placement is a classic Soroban pitfall), and gas-cost estimation. My workflow looks like this:

1. Draft the contract myself.

2. Ask Claude to attack it from an auditor's perspective.

3. Cross-reference findings with actual on-chain simulation.

This layered approach doesn't replace a professional audit—nothing does for mainnet deployments handling real value. But it dramatically raises the quality of what reaches the auditor's desk, cutting external audit turnaround because the low-hanging vulnerabili