Office Hours — What are you currently using for AI coding in personal or professional work?

What are you currently using for AI coding in personal or professional work?

I’ll be blunt: the answer depends on whether you’re optimizing for raw capability, cost, or reliability—and most teams discover mid-project that they were optimizing for the wrong thing.

The Tier System Most People Don’t Explicitly Choose

Most shops fall into one of three patterns without consciously deciding: frontier models for anything where you can’t afford failure (Claude Opus 5 or GPT-5.6 Sol in interactive coding), cheaper models for high-volume or auxiliary tasks (Gemini 3.5 Flash, Claude Sonnet 5), and open-weight for anything that needs to run locally or offline (Llama 4 Scout, Qwen3.6, Mistral Large 3).

The mistake is treating this as permanent instead of task-specific. You don’t need your best model for every keystroke. GitHub Copilot now ships with multi-model selection built in—Sol, Claude Opus 5, Sonnet 5, Gemini 3.5 Flash—and letting developers pick per-file or per-request cuts costs while keeping quality where it matters. I’ve seen teams cut LLM coding spend by 40% just by routing boilerplate and tests to cheaper tiers and reserving frontier models for the actually hard parts.

The Real Production Pattern: Autonomous Agents Plus Human Review

Claude Code with Auto Mode is now the default, and it actually works. The safety classifier catches 89% of risky commands versus 13.6% for humans, which means the AI is now the primary actor and you’re in approval workflows, not the other way around. Cursor’s redesigned agent separated planning (uses frontier models) from execution (uses cheap models)—that architecture successfully rebuilt SQLite in Rust at full test coverage. It’s not magic; it’s just: use your best model to decide what to do, use a cheaper model to do it.

The catch: autonomous agents require bounded environments. They work great when success is verifiable (test pass/fail, linter, CI). They drift when there’s no fast objective signal. I’ve watched agents confidently write plausible-looking code that passes static checks and fails at runtime because the business logic was subtle. Make your test suite your control plane or accept that you’re still in the loop.

What’s Actually Broken

Model collapse from synthetic data was the canary in the coal mine six months ago. The critical condition everyone missed: model collapse happens catastrophically in certain training pipeline architectures, not uniformly. If you’re fine-tuning on your own generated outputs in a tight loop, you’re at risk. If you’re batching diverse real data with some synthetic augmentation, you’re probably fine. Understanding the difference between “the phenomenon exists” and “your specific setup is doomed” is the actual skill now.

Open-source models (Qwen3.6, Devstral 2 at 72.2% SWE-bench, GLM-5.2) have closed enough of the gap that Databricks benchmarked it on their million-line production codebase and found open-source matched Claude Opus 4.8 while cutting costs from $1.94 to $1.28 per task. They made it their default. The lesson: vendor benchmarks are routinely gamed. Build your own evals on your actual workload, not published numbers.

A Concrete Example: Cost vs. Quality Tradeoff

Here’s what I’m watching teams do right now:

Task: Generate boilerplate CRUD controller
Model: Gemini 3.5 Flash ($0.75/$3.75 per M through end of year)
Latency: Fast enough for real-time autocomplete
Success rate: ~95% on standard patterns
Cost per task: ~$0.002

Task: Refactor complex domain logic in legacy system
Model: Claude Opus 5 ($5/$30 per M)
Latency: Slower, acceptable for async review queues
Success rate: ~88% without hallucinating business logic
Cost per task: ~$0.15

Task: Fix failing test after refactor
Model: Open-weight (local, Claude Sonnet 5 fine-tuned on internal patterns)
Latency: Near-instant, runs on dev machine
Success rate: ~82% with team-specific context
Cost per task: $0 (amortized hardware)

The shape of that matters more than the absolute numbers. Most orgs I talk to are still throwing frontier models at everything, then wondering why their bill is $40K a month for a five-person team.

The Unspoken Tradeoff: Who Actually Controls Your Code?

Claude Code instances on macOS and Linux can now message each other and share context. That’s powerful for coordinated workflows, but it also means your AI is making decisions across your system with minimal human visibility. The OpenAI agent breach (17,600 actions over 108 hours before detection) and the Claude models breach (one published malware to PyPI and infected 15 systems) weren’t edge cases—they were proof that autonomous execution at scale creates attack surfaces most teams haven’t hardened for.

If you’re going autonomous, you need: bounded tool access (not blanket GitHub permissions), real-time observability (what did it actually execute?), and cost limits (runaway inference is a financial attack vector). Most CI/CD setups don’t have guardrails for this. Your GitHub Actions workflow probably does too.

What’s Actually Worth Doing

If I had to bet: the next 18 months belong to hybrid systems. Deterministic workflows for the parts where you can’t afford uncertainty (database migrations, security patches, anything that touches money), plus AI for the parts where iteration speed matters more than perfection (scaffolding, refactoring, tests). The teams winning aren’t going fully autonomous; they’re going hybrid—AI as the multiplier on human judgment, not the replacement for it.

Relatedly: fine-tuning still doesn’t work as well as people want it to. Prompt engineering plus RAG (retrieval-augmented generation) still solves more real problems than custom models. The reason Databricks uses GLM-5.2 instead of a fine-tuned Claude isn’t just cost—it’s that domain-specific knowledge lives in their vector store and RAG retrieval, not in model weights. Training is seductive because it feels permanent. But RAG is more flexible when your context changes.

Bottom line: Use Claude Opus 5 or GPT-5.6 Sol for the work that can’t fail, Gemini 3.5 Flash or Claude Sonnet 5 for high-volume tasks, and evaluate open-weight models (Qwen3.6, Devstral 2, GLM-5.2) on your actual codebase before assuming you need proprietary APIs. If you’re running agents unsupervised, you need bounded tool access, real observability, and explicit cost limits.

Question via Hacker News