The AI Coding Stack
From Copilot to autonomous coding agents

1. The AI Coding landscape and mental model

Over the past three years, AI coding tools have leapfrogged several generations. Understanding this main line clarifies every product's positioning:

1. 2021-2023: the Copilot era — GitHub Copilot turned "code completion" into a default. Microsoft internal research showed that developers using Copilot completed 26.08% more pull requests; GitHub's official report: 88% of users felt more productive.
2. 2024: the IDE-native AI era — Cursor, Windsurf, and Cody upgraded AI from a plugin to a first-class IDE citizen, introducing "full-codebase context", "multi-file editing", and "Agent mode". Cursor's ARR hit $65M in November 2024, +6,400% YoY.
3. Late 2024 - 2025: the autonomous Agent era — Devin was the first to autonomously solve 13.86% of real GitHub issues on SWE-Bench (zero human prompts); Claude Code and Codex CLI made the "terminal AI engineer" a thing; Sonnet 4.5 pushed autonomous coding duration from 7 hours to 30 hours.
4. 2025-2026: Chinese explosion + platformization — Qwen3-Coder-480B tops the open-source rankings; Trae reaches 92% adoption at ByteDance with over 43% AI code contribution; OpenHands, Cline and other open-source projects pass 60k stars.

A pragmatic definition: AI Coding is the entire practice of using large language models, Agent frameworks, and IDE integrations to assist with or autonomously complete software engineering tasks. It has three layers: Completion → Chat → Agent. Each layer shifts the developer from "typing" to "deciding".

1.1 The AI Coding product matrix at a glance

1.2 Industry penetration (2024-2026)

• GitHub: about 30% of newly written code worldwide is assisted by Copilot; over 30% of Microsoft's 23,000 engineers use Copilot every day.
• Google CEO Sundar Pichai disclosed in the October 2024 earnings call: over 25% of new code at Google is AI-generated, then reviewed and accepted by engineers.
• Menlo Ventures 2024 survey: AI Coding is the highest-penetration enterprise AI scenario, reaching 51%.
• GitHub Copilot ARR has surpassed $3B, contributing over 40% of GitHub's overall growth.
• Cognition AI (Devin's parent) raised $495M in August 2025 at a $9.8B valuation; ARR jumped to $82M (mostly from the Windsurf acquisition).

2. Coding LLMs

The model is the "engine" of AI Coding. 2024-2026 saw coding models iterate much faster than general LLMs, driven mainly by the rapid rise of dedicated benchmarks: SWE-Bench, HumanEval, LiveCodeBench.

2.1 Closed-source flagship coding models

GPT-5-Codex milestones: 74.5% on SWE-bench Verified (500 prompts), beating GPT-5's 72.8%; internal "refactor task" accuracy jumped from 33.9% to 51.3%; autonomously works 7+ hours, iterating implementation, fixing tests, and submitting PRs. Most importantly, it supports "dynamic thinking" — after 5 minutes it can add 1 more hour of investment, rather than locking compute at task start. OpenAI internal: 40% of coding traffic was on it within 2.5 hours.

Claude Sonnet 4.5 — the 30-hour myth: 77.2% on SWE-bench Verified single-model, 82% with parallel inference; 61.4% on OSWorld (real computer tasks), setting a new industry record; in testing it independently generated 11,000 lines of code for a Slack-style chat app, running 30+ hours without losing focus. Combined with the Claude Agent SDK (formerly Claude Code SDK) + context editing + memory tools, an Agent can execute multi-day complex tasks in a 200K context. Pricing holds at $3/$15 (jumps to $6/$22.5 above 200K tokens).

Cursor Composer 2.5 is the 2026 dark horse: fine-tuned from Moonshot's Kimi K2.5, the standard version is only $0.50/$2.50 per M tokens, the Fast version is $3/$15. SWE-Bench Multilingual 79.8% puts it in the same tier as Claude Opus 4.7 and GPT-5.5, but at ~1/10 the per-task cost. 63.2% on CursorBench v3.1 — Cursor's own internal benchmark that's closer to real-world dev. Cursor 2.0 also moved to a multi-Agent collaborative interface, supporting multiple Agents working in parallel via git worktrees.

2.2 Open-source / open-weight coding models

Qwen3-Coder-480B is the open-source coding-model phenomenon of 2025: 7.5T training tokens (code 70%), native 256K / YaRN-extended 1M context; SOTA on the three Agentic Coding, Agentic Browser-Use, and Foundational Coding Tasks leaderboards. SWE-Bench matches Claude 4 Sonnet; Apache 2.0; fully commercial. Hugging Face CEO Clement Delangue posted 12 tweets in a single day endorsing it as "the best programming model". Together with the also-open-sourced Qwen Code CLI (a Gemini-CLI fork), it integrates with the Claude Code protocol — making it the top pick for on-prem deployments.

Qwen3-Coder-Next lowers the hardware bar further: 80B total / 3B active (96% sparsity) MoE; 4-bit quantization needs only 46GB of RAM; on a single RTX 4090 (24GB) + 128GB RAM box, SOTA coding quality that was unimaginable in the 7B era is now possible on a consumer GPU.

2.3 Key benchmarks (mainstream models, 2025-2026)

3. IDE integrations (AI in IDE)

IDE integration is the layer the user feels most directly. The 2024-2026 core trend: "AI from plugin to first-class IDE citizen". VS Code-based is still the absolute mainstream; Cursor / Windsurf / Trae push "full-codebase indexing" to the limit.

3.1 VS Code-based AI editors

3.2 Chinese IDE integrations

• ByteDance Trae — ByteDance's AI-native IDE launched in January 2025 (VS Code fork). Ships with Doubao 1.5 Pro, Claude 3.5/3.7 Sonnet, GPT-4o, and DeepSeek R1/V3 out of the box. Supports SOLO mode and Builder mode. The Cue feature is actively used by 50%+ of users every day, ~1B code recommendations cumulatively, adoption rate +80%. In 2025 Trae users generated nearly 100B lines of code globally.
• Tongyi Lingma / Qoder CN — from Alibaba Cloud. VS Code and JetBrains dual-side plugin. In April 2024 Alibaba Cloud made it mandatory internally, gave it employee badge "AI001", with the goal that 20% of future code will come from it. By 2025 it has generated 1.5B+ lines of code cumulatively, serving FAW Group, China Continent Property & Casualty, Hello, and 10,000+ enterprises. In May 2026 it was officially renamed Qoder CN — a brand upgrade to an agentic product line. Qoder 1.0 integrates Agent team collaboration.
• Wenxin Kuaima (ERNIE Code) — Baidu's Wenxin-powered coding assistant, deeply integrated with the PaddlePaddle ecosystem.
• CodeGeeX plugin — Tsinghua Zhipu, open-source; CodeGeeX4 supports 128K context, multi-IDE, strong in Chinese scenarios.
• iFlyCode / Xunfei Stars — iFlytek, strong Chinese voice interaction.
• CodeFlying — natural-language one-shot Web-app generation, the Bolt.new / v0 equivalent.
• CodeArts Snap — Huawei Cloud, enterprise-grade AI coding assistant, suited to government / state-owned trust scenarios.

3.3 Browser IDE / low-code Vibe Coding

• v0.dev — Vercel. Focused on UI component generation, based on shadcn/ui + Tailwind CSS. Free tier available; Pro $20/mo, Team $30/dev·mo, Enterprise custom. Strong in "screenshot → replicate" and "component-level targeted tweaking" — many use v0 as a "front-end finetuner".
• StackBlitz Bolt.new — runs Node.js in the browser (WebContainers) + AI Agent. 8 weeks from 0 → $20M ARR, raised $83.5M in January 2025 at a $700M valuation. Based on Claude Sonnet. Free tier 5M tokens/mo, Pro $20/mo, Teams $80/mo. Specialty: 0-to-deploy full chain — the real "Vibe Coding" reference.
• Replit Agent — Replit, September 2024, the first C-end "conversational site builder" Agent — from Vibe Coding to full Web app dev. November 2024 valuation $3B, ARR growing fast.
• Lovable — Swedish Lovable AI. In 5 weeks of 2024 its valuation shot to $2.6B — paired with Bolt.new as the "Vibe Coding twins".
• CodeSandbox / Project IDX (Google) — Google's cloud IDE built on CodeSandbox, with built-in AI.

4. CLI agents

CLI Agents are the hottest track of 2025 — turning the "terminal" into the main interface where the Agent collaborates with developers. Great for Git workflows, CI/CD, and remote servers.

4.1 OpenAI Codex CLI

First released April 2025; re-architected when GPT-5-Codex landed in September. Fully open-source (GitHub 36.7k+ stars), supports the GPT-5-Codex backend, multi-modal (paste screenshots / wireframes), MCP, to-do list self-tracking, and 3 approval modes (read-only / auto / full access). Requires a ChatGPT Plus/Pro/Business/Edu/Enterprise subscription. The Codex CLI design philosophy: treat "AI engineer" as a long-term collaborator. Sandboxed security + multi-modal input + full toolchain are the core differentiators.

4.2 Anthropic Claude Code

GitHub 31.6k+ stars. Based on the Claude 4 family (Sonnet 4.5, Opus 4.5), accessed through the Claude Agent SDK (formerly Claude Code SDK). Core capabilities: whole-repo code indexing, sub-Agent delegation, permission system, checkpoint rollback, context editing, memory tools, VS Code extension + GitHub Actions integration. Pricing: Free / Pro $20 / Max 5× $100 / Max 20× $200 (per 5-hour interaction window), or pay-as-you-go API: Sonnet 4 $3/$15, Opus 4 $15/$75. Claude Code's strength is "controllable end-to-end tasks" — the full loop from requirement to PR.

4.3 Aider

GitHub 45.8k+ stars (mid-2024: 30k+; September 2025: 45k), Apache-2.0. The open-source CLI led by Paul Gauthier, works directly in your local Git repo, supports GPT-4o, Claude 3.5/3.7/4 Sonnet/Opus, DeepSeek V3/R1, Gemini 2.5 Pro — basically every major LLM. tree-sitter-based dependency-aware smart file selection; the RepoMap algorithm prioritizes files containing referenced identifiers. Features: multi-file editing, auto Git commits (with proper commit messages), auto linter, voice mode, architect mode (a stronger model plans, a cheaper model edits). Typical use: aider --model claude-sonnet-4-5 file1.py file2.py. Aider shines on "long context + large projects" — long-standing SOTA among open-source tools on SWE-Bench.

4.4 Cline (formerly Claude Dev)

GitHub 49.8k+ stars (mid-2024: 30k+), 1.97M+ installs, Apache-2.0. A VS Code AI Agent plugin. First scans the project AST, generates an execution plan, then calls the LLM to autonomously create/modify files, run commands, take screenshots, test; MCP protocol supports external systems (DB, API, browser). All actions require human confirmation. Supports OpenRouter, Anthropic, OpenAI, Gemini, AWS Bedrock, Ollama. Cline's strength is "the Devin-like experience inside VS Code" — free + bring your own API key.

4.5 OpenHands (formerly OpenDevin)

GitHub 64k+ stars (mid-2024: 40k+), MIT license. All-Hands AI's open-source platform. Full GUI integration of a VS Code-style editor, terminal, and browser; supports multi-Agent collaboration, 100+ LLM routing, remote sandbox execution, native MCP integration. On SWE-Bench Verified with Claude Sonnet 4.5 + extended thinking, 72% solve rate; with Qwen3 Coder 480B, 41.21%. In 2025 it released the Software Agent SDK, upgrading from a V0 monolith to a V1 modular design (SDK / Tools / Workspace / Agent Server). OpenHands is the closest open-source AI software engineer to "fully formed".

4.6 Other notable CLI Agents

• Roo Code / Cline fork — GitHub 19k+ stars, positioned as "the entire AI dev team in your editor"; multi-role Agents (Architect / Coder / Debugger), MCP protocol, full-repo indexing.
• Kilo Code — 7.2k+ stars, community-driven, blends Cline and Roo features, $15-20 free model credits.
• Goose (Block) — autonomous Agent, fully open-source, supports any LLM and MCP extension.
• Warp 2.0 — 500k+ users, GPU-rendered terminal UI, built-in AI, Pro $15/mo, Turbo $40/mo.
• Mistral Codestral / DevStral — 22B coding model, strong Fill-in-the-Middle, Devstral focused on Agent tasks.
• Gemini CLI — Google, 72.1k+ stars, completely free, 1000 calls/day, million-token context.

5. Autonomous coding agents

Autonomous Agents are the "holy grail" of AI Coding — can AI complete the entire task from requirement understanding to deployment? 2024-2026 has been astonishing.

5.1 Devin (Cognition AI)

Burst onto the scene in March 2024 — the first commercial autonomous AI software engineer. The 10-person founding team has IOI gold medals each. 13.86% of real GitHub issues solved independently on SWE-Bench (zero human prompts; GPT-4 was 1.74% at the time). Opened in December 2024 at $500/mo. In 2025 Devin 2.0 was released: price dropped to $20/mo (2.25/agent compute unit), added parallel Devins, interactive cloud IDE, interactive planning. In July 2025 Cognition acquired Windsurf for $220M, gaining 350+ enterprise customers and $82M ARR. In August 2025 it raised $495M at a $9.8B valuation (145% growth in 6 months). Internally at Cognition: Devin now handles 89% of code submissions, mostly "maintenance tasks developers don't want to do".

5.2 SWE-Agent (Princeton)

Princeton's open-source research project, GPT-4 + custom Agent-Computer Interface (ACI). First open-source tool to break 12% on SWE-Bench, validating that "an interface designed for LLMs" is the key to Agent capability. The de-facto baseline in academia.

5.3 OpenHands / OpenDevin

See §4.5. In November 2024 it became the first open-source Agent to break 50% on SWE-Bench. In the past month, OpenHands' contribution to its own codebase exceeded that of all human engineers. In 2025 it released the Software Agent SDK, with major production-grade improvements.

5.4 Chinese Devin-likes

• Alibaba Tongyi Lingma AI Engineer — released at the 2024-09 Apsara Conference. Can go from 0 to 1 to deliver a full app in minutes.
• ByteDance Doubao MarsCode / Trae SOLO — Trae's SOLO mode lets the Agent autonomously call tools, run commands, edit across files. ByteDance's Douyin lifestyle-services team: AI code contribution over 43%.
• CodeGeeX4-AIDE / CodeFlying — end-to-end site-building Agents.
• Alibaba Qoder 1.0 — released May 2026. Positioned as "an Agent autonomous-dev workstation": the user focuses on defining requirements, the Agent team autonomously handles execution, verification, and delivery.

5.5 Multi-Agent collaboration frameworks

• MetaGPT — GitHub 60k+ stars. Maps a software company (Scrum Master, Architect, Engineer) onto multiple Agents — end-to-end "auto" product.
• ChatDev — Tsinghua open source. Maps "waterfall development" to a Chat Chain (Design → Code → Review → Test) — full traceability.
• AutoGPT / AgentGPT — autonomous goal-driven, GitHub 166k+ stars, pioneering, but production stability still maturing.

5.6 Autonomous Agent scorecard (2025 Q4 snapshot)

6. Code completion and snippets

Completion is the "entry-level" form of AI Coding — but 2024-2026 it has kept evolving on enterprise-grade, on-prem, and multi-model routing.

7. Code review and quality (AI Code Review)

Code review is "the last moat of software engineering". AI tools are cutting review time from 2-3 hours to 20-30 minutes.

7.1 Mainstream AI Code Review tools

7.2 Selection framework

• Fast feedback + low friction → CodeRabbit / GitHub Copilot Code Review / Graphite
• Complex authorization / security-logic review → Greptile / Ellipsis / LinearB
• Large codebase + cross-file reasoning → Greptile (codebase graph) / Augment (Context Engine indexes 400k+ files)
• Data sovereignty / regulated industries → Greptile self-hosted / Tabby / PR-Agent self-hosted + Ollama
• Small team + cost-sensitive → CodeRabbit or PR-Agent (open-source)
• 100+ developers + existing DevOps → open-source self-hosted starts to show long-term cost advantage

8. Real-world case studies

Cases are more persuasive than feature lists. The 8 cases below are real data from public reports.

Case 1: ByteDance Trae — 92% internal penetration + 100B lines of code

December 2025: ByteDance's Trae CN Enterprise data:

• Over 92% of ByteDance engineers use Trae daily;
• Personal version has 6M registered users, 1.6M MAU, covering 200+ countries and regions;
• In 2025 TRAE users globally generated nearly 100B lines of code;
• The Douyin lifestyle-services team: AI code contribution over 43%, weekly test-case generation saves 44.56 person-days, unattended publishing saves 25 minutes per run;
• The Cue code-completion feature is actively used by 50%+ of users daily, with ~1B code recommendations cumulatively, adoption rate up over 80%; SOLO mode user penetration 44%.
• Customer cases: Huifu Tianxia (peak R&D usage > 70%).

Takeaway: the trinity of "AI-native IDE + in-house LLM + 92% internal usage" made Trae the benchmark of Chinese AI Coding in 2025.

Case 2: Alibaba Tongyi Lingma — badge AI001, 1.5B lines of code

April 2024: Alibaba Cloud made internal AI Coding mandatory, giving Tongyi Lingma the official employee badge "AI001". An Alibaba Cloud executive disclosed: "20% of the company's future code will be written by Tongyi Lingma."

• In API development and testing, dozens of minutes of manual test writing were compressed to seconds, saving 70%+ of test-code effort;
• Plugin downloads 8-20M (varying by time), 1.5B+ lines of code generated cumulatively;
• Code adoption rate in Java, Python, Go and other mainstream languages all > 30%; enterprise customers include FAW Group, China Continent Property & Casualty, Hello, and 10,000+ others;
• September 2024 Apsara Conference: "Tongyi Lingma AI Engineer" released, upgraded from Copilot to Agent mode — full app dev from 0 to 1;
• May 2026: officially renamed Qoder CN; Qoder 1.0 — the Agent autonomous-dev workstation, serving 5M+ users globally.

Case 3: Microsoft GitHub Copilot — 23,000 engineers, 30%+ code AI-generated

At Build 2024 Microsoft disclosed: 23,000 Microsoft engineers (almost the whole company) use GitHub Copilot daily; per the CEO's internal report, "over 30% of new code is AI-generated". Data came from three RCTs run by Microsoft, MIT, Princeton, and Wharton, covering ~5,000 developers:

• Pull-request throughput up 26.08% on average;
• 55% of developers reported "faster code-writing speed";
• 88% reported "more productive";
• GitHub Copilot ARR surpassed $3B, contributing over 40% of GitHub's overall growth.

Case 4: Google Duet AI — 25%+ new code AI-generated

October 2024 Google earnings call, CEO Sundar Pichai disclosed: "over 25% of Google's new code is AI-generated, then reviewed and accepted by engineers." Google's internal AI tool Duet AI (later integrated into Gemini) is deeply embedded in Workspace and dev workflows — the benchmark for "hyperscale internet company AI Coding transformation".

Case 5: Goldman Sachs rolls out Devin — thousands of seats for enterprise Agents

Per Cognition AI's disclosure, Goldman Sachs partnered with Cognition to deploy thousands of Devin seats for internal software engineering and financial data processing. In Goldman's internal tests, Devin handles "tedious maintenance tasks" that traditional engineers don't want to do: legacy-system migration, application upgrades, report automation. Cognition CEO Scott Wu: "We never intended to replace humans. AI is the engineer's partner, letting one person do what previously took 5."

Case 6: Cognition AI's commercialization — 0 → $82M ARR

Cognition AI's funding history is a venture-capital fairy tale:

• November 2023: angel round (Peter Thiel invested);
• Early 2024: Series A (Founders Fund), $2B valuation, ARR under $500k;
• March 2025: Series B, $4B valuation;
• July 2025: $220M flash acquisition of Windsurf, gaining 350+ enterprise customers and $82M ARR;
• August 2025: Series C $495M, valuation $9.8B (145% growth in 6 months).

Devin internal stats: 89% of code submissions are done by Devin, mostly "maintenance, migration, upgrade" tasks that engineers don't want to do.

Case 7: StackBlitz Bolt.new — 8 weeks from 0 to $20M ARR

October 2024 Bolt.new launched. Using WebContainers to run Node.js in the browser, "Vibe Coding" became reality. Within 8 weeks:

• ARR grew from 0 to $20M (faster than Zoom, Salesforce at the same stage);
• January 2025: raised $83.5M at a $700M valuation (Emergence Capital + GV led);
• May 2025: 2M registered users, ARR past $40M;
• Business model: $50/month buys 26M tokens, one-click deploy to Netlify / Cloudflare;
• 2026: Bolt closed a $105.5M round (Series A $22M + follow-on $83.5M).

Case 8: 6 real-world demo scenarios

1. Figma → React component: v0 / Bolt turns a design into an interactive React component (Tailwind + shadcn/ui) in 5-10 minutes from a screenshot.
2. Understanding a legacy project: with Claude Code / Cursor @Codebase, ask the old project "who calls this function / why is it designed this way / is there a similar implementation" — understanding cost down 10×.
3. Automated PR fix: Greptile emits line-level comments when a PR opens; trigger Claude Code to auto-apply; humans only do accept/reject. Brex cut PR merge time from 20h to 1.8h with this flow.
4. End-to-end bug fix: Devin autonomously takes a GitHub Issue → reproduces → writes fix → runs tests → opens PR; engineers only review at the end. Devin solved 13.86% of real issues independently on SWE-Bench.
5. Large-scale refactor: Aider + Claude Sonnet 4.5 renames/moves/abstracts across 200+ files, auto Git commit + test. GitHub Copilot's internal team uses a similar flow for daily refactors.
6. Database migration: Claude Code executes multi-step: analyze schema → generate migration → dry-run → backup → real run → verify — all in a sandboxed, rollback-capable environment.

Case 9: failure cases and pitfalls

• Slack data leak (2023) — multiple companies had other users' conversation summaries leaked when using LLMs to analyze user data, due to "context window auto-injection". Lesson: all data sent to the LLM must go through PII filtering + minimization.
• Copilot code attribution disputes (2022 - present) — Copilot generates code 0.1-1% of the time that is highly similar to training data, leading to GPL warnings for some companies. GitHub provides a "duplication detector" filter, but teams still need license audits.
• AI-introduced security vulnerabilities — GitClear 2024 analysis of 153M modified lines: with Copilot the "refactor rate" rose 73% while churn fell — meaning less refactoring, more tech debt. CodeRabbit: AI-generated code creates 1.7× more issues than human code.
• The "70% problem" — AI can do 70% of the work, but the last 30% (complex business logic, edge cases, architecture integration) still needs human experts; for non-engineers using AI, that 30% often becomes a mountain of tech debt.
• Learning curve — Microsoft research: AI tools save 11 min/day net, but it takes 11 weeks of consistent use to reach net positive — early on there's a clear productivity dip. Blind deployment + short-term evaluation leads to a false "the tool doesn't work" conclusion.

9. AI Coding workflow best practices

9.1 Individual developer workflow (from requirement to PR)

1. Clarify the requirement — turn "I want a login feature" into "GitHub OAuth login + JWT token + 7-day expiration" — reduces the cost of AI guessing wrong.
2. Cursor Composer draft — use Composer mode 1 to quickly scaffold. Pick Claude Sonnet 4.5 / GPT-5-Codex.
3. Claude Code verification — in the terminal, run tests, check git diff, confirm it follows project conventions.
4. Aider refactor — for large-scale changes (200+ files), use Aider in architect mode.
5. Write tests by hand — AI-generated tests look good on coverage but often miss business edge cases; add your own edge cases.
6. Greptile pre-review + submit PR — let the AI review once before submitting; reduces reviewer load.

9.2 Team workflow (standards and security)

• Code review checklist:
  • AI-generated code must have a human review sign-off (especially for security, payment, data migration);
  • Core business logic (over N lines of business-critical code) must be human-led;
  • AI-generated PRs must include a "test coverage + edge conditions" section;
  • Large refactors (> 500 lines diff) must be split into smaller PRs.
• AI tool usage policy:
  • Free tier handles daily completion; sensitive code goes through Enterprise / self-hosted;
  • Turn off Copilot data collection for critical projects (Settings → Copilot → Privacy);
  • Never send code containing customer PII to external services;
  • Review AI tool token spend weekly; set a hard budget cap.
• Security & compliance:
  • Finance / healthcare / government: must use self-hosted (Codeium Enterprise / Tabby / Greptile self-host);
  • Audit: all AI-generated commits must be traceable to the specific prompt + model version (paired with tools like OpenLineage);
  • Compliance: ensure the model and tools you use meet industry regulations (HIPAA for healthcare, PCI-DSS for finance, GDPR for Europe).

9.3 Prompt tips (code-generation specific)

Beyond general prompt tips, code prompts should also note:

# Recommended template
# Role: you are a [senior Python engineer / React performance specialist]
# Context: the project uses [FastAPI + PostgreSQL + Redis]; the team follows PEP 8 / Google JS style
# Task: [optimize the query performance of this endpoint, drop latency from 800ms to under 200ms]
# Constraints:
#   - cannot change database schema
#   - must be compatible with the existing SQLAlchemy 2.0 async pattern
#   - cannot introduce new dependencies (except aiocache)
# Output: give 3 options, each labeled [implementation cost / perf gain / risk]
# Verification: list how to benchmark and verify

Key tips:

• Give context, not commands — "optimize this query" > "add an index"; let the AI decide the approach.
• Constraints beat instructions — "cannot introduce new dependencies" works better than "use the least code".
• Role + project context + task + constraints + output format — the five-piece set.
• Ask for multiple options + risk assessment — not just the final answer.

9.4 Context management strategy

The context window is the "memory" of AI Coding; how you manage it directly determines the result.

• Layered loading: core files in full + peripheral file summaries + a whole-repo RepoMap (Aider style).
• Chunking: keep a single task's context under 50K tokens; actively compress / summarize beyond that.
• Avoid redundancy: don't always load README.md and config files in full — replace already-read files with reference IDs.
• Periodic checkpoints: Claude Code's /rewind and Aider's /undo are must-haves; checkpoint every 30 minutes on long tasks.
• MCP integration: DB schema, CI status, issue trackers are pulled on demand via MCP — not stuffed into the prompt.

10. Learning resources and community

10.1 Official documentation

• OpenAI Cookbook — Code Generation
• Anthropic Cookbook — Claude for Coding
• Cursor Docs
• Claude Code official docs
• Aider docs
• OpenHands docs
• Qwen3-Coder repo

10.2 Structured courses

• DeepLearning.AI: Building Applications with AI Agents (Andrew Ng)
• DeepLearning.AI: Claude Code in Action (Anthropic partnership)
• Cursor official video tutorials (YouTube channel)
• Prompt Engineering for Developers (DeepLearning.AI short course)

10.3 Industry podcasts and media

• Latent Space (swyx & Alessio) — the most influential AI engineering podcast, continuously tracking AI Coding progress.
• How AI Built This (Noah Kalina) — interviews with first-line AI-tool founders.
• Changelog — Cursor and Windsurf team podcast, focused on developer experience.
• GitHub Blog: Open Source Friday — in-depth coverage of AI Coding open-source projects.

11. Suggested learning paths

Beginner developer (0-1 year experience)

1. Install GitHub Copilot Personal (free for students) and spend 1 week getting used to in-line completion.
2. Learn to use GitHub Copilot Chat to explain unfamiliar code.
3. Try v0.dev to make a static page as practice.
4. Learn the "5-piece" prompt template and build a habit of asking clearly.

Intermediate developer (1-3 years experience)

1. Upgrade to Cursor Pro ($20), try Composer multi-file editing.
2. Learn Claude Code or Codex CLI, run tests in local projects.
3. Install Cline + bring your own DeepSeek / Qwen API key, experience "Devin in VS Code".
4. String the "PR flow" together with AI tools: write code → Aider commit → Greptile pre-review → open PR.
5. Read 1-2 Anthropic Cookbook or OpenAI Cookbook articles per month.

Advanced developer (3+ years experience)

1. Deep-dive into the Claude Code Agent SDK or OpenHands SDK, build a custom team Agent.
2. Research Qwen3-Coder / DeepSeek V3 quantized deployment, and string together a full offline workflow with local LLM + Continue / Tabby.
3. Promote "AI Coding standards" in the team, build PR templates, code review checklists, and token budgets.
4. Follow SWE-Bench / LiveCodeBench and other benchmarks, track the frontier of model capability.
5. Write the team's internal "AI Coding case library" — accumulate best practices.

12. Common FAQ

Q1: I'm a beginner — what's the first AI Coding tool I should pick?

GitHub Copilot Personal, free for students — just install the VS Code plugin. Start with "in-line completion" + "Chat explains code". Don't jump straight to Cursor Composer or Devin.

Q2: Is Cursor $20/mo worth it?

If you are a professional developer (2+ hours of coding per day), $20 for Composer is well worth the price — under $1/day. Ultra $200/mo is only recommended for high-frequency Agent users (5+ tasks/day) or team managers.

Q3: Claude Code vs Codex CLI — how to choose?

It depends on your "model preference". Claude Code shines on "controllable end-to-end tasks"; Sonnet 4.5 is more reliable for long-horizon coding, financial analysis, and replicating research. Codex CLI shines on "dynamic thinking + sandbox safety"; GPT-5-Codex is stronger on PR review and dynamic multi-step tasks. We recommend installing both and choosing per task.

Q4: Can open-source models replace closed-source?

The 2026 answer: "yes for 80% of tasks". Qwen3-Coder-480B is on par with Claude 4 Sonnet on SWE-Bench; Composer 2.5 (based on Kimi K2.5) is in the same tier as Opus 4.7 but 10× cheaper; Qwen3-Coder-Next lets you get close-to-SOTA quality on a $4,000 box. But the remaining 20% — long-horizon tasks, complex debugging, security audits — still warrants closed-source flagships.

Q5: Will Devin replace programmers?

Short term: no. Long term: it will change what the work is. Cognition's own disclosure: Devin handles 89% of code submissions internally, but most of those are "maintenance, migration, upgrades" — repetitive. The truly creative work — designing new systems, architecture decisions, complex business modeling — still needs humans. Scott Wu: "We never intended to replace humans. AI is a partner."

Q6: Data security? Will my code be used for training?

Three tiers: (1) Personal / Enterprise accounts can disable "allow GitHub to use my code snippets to improve AI" in Settings → Copilot → Privacy; (2) Business / Enterprise tiers do not train by default; (3) Finance / healthcare should use self-hosted (Tabby / Codeium Enterprise / Greptile self-host).

Q7: I'm a small business on a tight budget. Which tools should I pick?

Totally free combo: Trae (international / Chinese version) + Tongyi Lingma (basic free) + Continue + Ollama running Qwen2.5-Coder-7B. One local, one cloud, $0/month — covers 90% of scenarios.

Q8: My team already uses Copilot — should we switch to Cursor?

Depends on team size and scenarios: < 10 people — switch to Cursor Pro, the difference is clear; 10-50 people — start with a small pilot, Cursor Teams at $40/dev·mo is not cheap; 50+ people — keep Copilot + pilot Cursor + a Chinese option (Tongyi Lingma / Wenxin Kuaima), pick a three-way combo rather than all-in.

Q9: What is Vibe Coding — is it real or hype?

Real trend. The essence: developers use natural language to express intent, AI generates / executes / iterates code, humans are the requirement-setter and reviewer. 91% of engineering teams adopted vibe coding in 2026. MIT Technology Review listed it as a "Top 10 Breakthrough Technology of 2026". It will not replace professional coding, but it will create a "1B new developers" market.

Q10: What's the next big breakthrough?

Three directions to watch:

1. Multi-Agent collaboration — single Agent has hit its ceiling; Cursor 2.0's multi-Agent + git worktree model is the start;
2. Continuous AI — GitHub Agentic Workflows is already in preview; Agents move from "passive responder" to "proactive maintainer";
3. AI self-iteration — the Qwen team already uses Agents to clean training data; Cursor Composer 2.5's "function-deletion" synthetic-task training is an early practice of AI training AI. By 2027 we may see "fully self-trained" new models.

13. Chapter summary

• ✅ Model layer: closed-source flagships (GPT-5-Codex / Sonnet 4.5 / Opus 4.5) + open-source #1 (Qwen3-Coder-480B / Composer 2.5). SWE-Bench Verified past 80%.
• ✅ IDE integration: VS Code-based still the absolute mainstream. Cursor / Windsurf / Trae push "full-codebase Agent". Chinese IDEs are rising fast.
• ✅ CLI Agent: Claude Code / Codex CLI / Aider / Cline / OpenHands form a complete ecosystem. Combined GitHub stars > 300k.
• ✅ Autonomous Agent: Devin broke through commercially (Cognition at $9.8B). OpenHands narrowed the open-vs-closed gap. 30+ hour long-horizon coding is real.
• ✅ Code review: CodeRabbit / Greptile / PR-Agent redefined the PR flow. Average PR merge time from 20h → 1.8h.
• ✅ Real deployments: 30%+ of new code at Microsoft (23,000 engineers) is AI-generated; 92% of ByteDance engineers use Trae, AI code contribution 43%; Alibaba "AI001" Tongyi Lingma generated 1.5B lines.
• ✅ Next 12-24 months: multi-Agent collaboration + continuous AI + self-trained models.

14. Agent Skills in coding practice

After Anthropic released Agent Skills in October 2025, Skills has moved from "a small Claude feature" to a cross-platform open standard. This section focuses on coding scenarios: from code review, test generation, to refactoring, commit standards, deployment checks — Skills package high-frequency engineering moves into "software capability packs" that can be auto-triggered, letting AI engineers reuse engineering experience like function calls.

14.1 Five coding applications of Skills

1. Code review — after loading the code-review Skill, Claude auto-reviews PRs on 4 dimensions (spec compliance / code quality / security / performance) with Critical / Important / Minor ratings, filtering comments below 80% confidence. Big PRs surface an average of 7.5+ real issues.
2. Test generation — the test-driven-development Skill enforces the RED → GREEN → REFACTOR loop, writing failing tests before implementation, plus anti-pattern checks (don't mock behavior, don't pollute production classes for tests).
3. Refactoring — the refactor-assistant Skill runs AI through a "spec-compliance review + code-quality review" two-stage refactor, dispatching a new sub-Agent per sub-task to isolate context.
4. Commit standards — the git-commit-helper Skill encodes the Angular Commit / Conventional Commits templates in SKILL.md, auto-generating compliant commit messages so PR descriptions are no longer a rainbow.
5. Deployment checks — the deployment-check Skill runs security scans, dependency audits, config-drift detection, and migration-compatibility checks before merge, keeping production incidents on the night before merge.

---
name: python-code-reviewer
description: Trigger when the user submits Python code, requests a PR review, or mentions "code review / PEP 8 / code quality". Strictly review on 4 dimensions with actionable suggestions — avoid baseless conclusions like "looks fine".
---

# Python Code Reviewer

You are a senior Python engineer with 12 years of experience + a security auditor. When reviewing code, you must output section by section on the 4 dimensions, with every conclusion citing a specific line or code snippet.

## When to trigger
- The user asks to review / look at this code
- Before submitting a PR
- Any long file containing def / class / import

## Review dimensions (must cover all 4)

### 1. Spec compliance (0-10)
- Does it implement the user's original requirement?
- Anything missing or over-engineered?
- Edge conditions (empty input, None, very large data) — handled?

### 2. Code quality (0-10)
- Type-annotation coverage (target 100%)
- Function length (target < 50 lines)
- Cyclomatic complexity (target < 10)
- DRY: is repeated logic abstracted?
- Naming: PEP 8 compliant?

### 3. Security (0-10, Critical is instant block)
- SQL injection (must use parameterized queries)
- Pickle / eval / exec usage
- Hard-coded keys / credentials
- Unsafe deserialization

### 4. Performance (0-10)
- N+1 queries
- Unnecessary list copies
- Blocking I/O in async context
- Cache hit rate

## Output format
```
[Critical]  File:line  Description  Fix suggestion
[Important] ...
[Minor] ...
Overall score: X.X / 40
Mergeable: ✅ / ❌ (only mergeable if Critical count = 0)
```

## Anti-rationalization checklist
- "This import should be fine"  → must actually import and verify
- "I already tested it manually"  → manual testing is not a substitute for automated tests
- "Looks correct"  → must give a run-verification command

## Error handling
- User provided incomplete code → ask for the full snippet
- User only asks "is it good?" → must score on all 4 dimensions

"""AI Translation Helper backend - Flask + Claude API.

Usage:
    ANTHROPIC_API_KEY=sk-ant-... python backend/app.py
"""
from flask import Flask, request, jsonify
from flask_cors import CORS
from dotenv import load_dotenv

load_dotenv()
app = Flask(__name__)
CORS(app)
client = anthropic.Anthropic(api_key=os.environ["ANTHROPIC_API_KEY"])

# Supported languages
SUPPORTED = {"zh": "Chinese", "en": "English", "ja": "Japanese"}

SYSTEM_PROMPT = """You are a professional translator.
Translate the user's text from {src} to {tgt}.
Output ONLY the translation, no quotes, no explanation, no markdown."""


@app.get("/api/health")
def health():
    """Health check."""
    return {"status": "ok", "supported": SUPPORTED}


@app.post("/api/translate")
def translate():
    """Core translation endpoint. Body: {text, src, tgt}."""
    data = request.get_json(force=True)
    text = (data.get("text") or "").strip()
    src = data.get("src", "auto")
    tgt = data.get("tgt", "en")
    if not text:
        return jsonify({"error": "text is required"}), 400
    if tgt not in SUPPORTED:
        return jsonify({"error": f"unsupported tgt: {tgt}"}), 400
    try:
        msg = client.messages.create(
            model="claude-haiku-4-5",
            max_tokens=1024,
            system=SYSTEM_PROMPT.format(
                src=SUPPORTED.get(src, src), tgt=SUPPORTED[tgt]
            ),
            messages=[{"role": "user", "content": text}],
        )
        translated = msg.content[0].text.strip()
        return jsonify({
            "translation": translated,
            "src": src,
            "tgt": tgt,
            "usage": {"input_tokens": msg.usage.input_tokens, "output_tokens": msg.usage.output_tokens},
        })
    except anthropic.APIError as e:
        return jsonify({"error": str(e)}), 502


if __name__ == "__main__":
    app.run(host="0.0.0.0", port=5000, debug=True)

import { useState } from "react";

const LANGS = [
  { code: "zh", name: "Chinese" },
  { code: "en", name: "English" },
  { code: "ja", name: "Japanese" },
];

const API = "http://localhost:5000";

export default function App() {
  const [text, setText] = useState("");
  const [src, setSrc] = useState("zh");
  const [tgt, setTgt] = useState("en");
  const [result, setResult] = useState("");
  const [loading, setLoading] = useState(false);
  const [err, setErr] = useState("");

  const onTranslate = async () => {
    if (!text.trim()) return;
    setLoading(true);
    setErr("");
    try {
      const r = await fetch(`${API}/api/translate`, {
        method: "POST",
        headers: { "Content-Type": "application/json" },
        body: JSON.stringify({ text, src, tgt }),
      });
      if (!r.ok) throw new Error((await r.json()).error || "Request failed");
      const j = await r.json();
      setResult(j.translation);
    } catch (e) {
      setErr(e.message);
    } finally {
      setLoading(false);
    }
  };

  const onCopy = async () => {
    await navigator.clipboard.writeText(result);
  };

  const onSwap = () => {
    setSrc(tgt);
    setTgt(src);
  };

  return (
    <div className="min-h-screen bg-gradient-to-br from-indigo-50 to-purple-50 p-8">
      <div className="max-w-2xl mx-auto bg-white rounded-2xl shadow-xl p-8">
        <h1 className="text-3xl font-bold text-gray-800 mb-6">🌍 AI Translation Helper</h1>

        <div className="flex items-center gap-3 mb-4">
          <select value={src} onChange={(e) => setSrc(e.target.value)}
            className="flex-1 px-3 py-2 border rounded-lg">
            {LANGS.map((l) => (
              <option key={l.code} value={l.code}>{l.name}</option>
            ))}
          </select>
          <button onClick={onSwap} className="px-3 py-2 text-xl">⇄</button>
          <select value={tgt} onChange={(e) => setTgt(e.target.value)}
            className="flex-1 px-3 py-2 border rounded-lg">
            {LANGS.map((l) => (
              <option key={l.code} value={l.code}>{l.name}</option>
            ))}
          </select>
        </div>

        <textarea
          value={text}
          onChange={(e) => setText(e.target.value)}
          placeholder="Enter the text to translate..."
          rows={6}
          className="w-full px-3 py-2 border rounded-lg mb-4"
        />

        <button
          onClick={onTranslate}
          disabled={loading || !text.trim()}
          className="w-full bg-indigo-600 text-white py-3 rounded-lg font-semibold hover:bg-indigo-700 disabled:opacity-50">
          {loading ? "Translating..." : "🚀 Translate"}
        </button>

        {err && (
          <div className="mt-4 p-3 bg-red-50 text-red-700 rounded-lg">{err}</div>
        )}

        {result && (
          <div className="mt-6">
            <div className="flex justify-between items-center mb-2">
              <h2 className="text-lg font-semibold">Translation</h2>
              <button onClick={onCopy} className="text-sm text-indigo-600 hover:underline">
                📋 Copy
              </button>
            </div>
            <div className="p-4 bg-gray-50 rounded-lg whitespace-pre-wrap">{result}</div>
          </div>
        )}
      </div>
    </div>
  );
}

# Terminal 1: backend
cd backend
echo "ANTHROPIC_API_KEY=sk-ant-xxx" > .env
pip install -r requirements.txt
python app.py
#  → Running on http://127.0.0.1:5000

# Terminal 2: frontend
cd frontend
npm install
npm run dev
#  → Local: http://localhost:5173/

codex "Create a Vercel deployment config in the current directory:
- backend/ uses Vercel Python Serverless Function, entry point api/index.py
- frontend/ uses Vite static build, output directory vercel.json points to dist
- root vercel.json handles both /api/* and SPA fallback
- Output the final directory tree and the full vercel.json content"