Using AI to write better code more slowly
AI coding tools are increasingly being used less as “10x speed” generators and more as slow, iterative collaborators for planning, code review, and bug-hunting. Many developers describe workflows where they design features themselves, then use one or more LLMs to propose implementations, critique each other’s output, and refine code quality, often ending up at what feels like a “v3” implementation on the first release. Others push back that this can be token-expensive, cognitively draining, and risks eroding deep understanding, arguing that AI works best as an augmenting tutor, rubber duck, and test writer rather than an autonomous code author.
Roles AI Plays in Coding
- Used as tutor, rubber duck, and design partner: explain unfamiliar tech, critique plans, suggest alternatives, generate practice problems, and help with specs/PRDs.
- Popular as code reviewer and bug-finder: spot corner cases, security issues, performance bottlenecks, inconsistent patterns, and missing tests.
- Often employed for boilerplate, repetitive refactors, test generation, documentation, and comments, while humans handle architecture and critical paths.
Workflows and Practices
- Many describe multi-step loops: human drafts requirements → AI proposes plan → human refines → AI implements in small chunks → AI(s) review → tests/benchmarks → further refactors.
- Some orchestrate multiple models in series or parallel (implementation vs review vs specialized audits) and use skills/guardrails (e.g., “don’t hand-roll, prefer libraries”; “treat each change as a PR with tests”).
- Others prefer minimalism: write most code by hand, let AI fill small gaps, review code, or generate specs from conversations.
Speed, Productivity, and Cost
- Some claim substantial speedups (e.g., “v3-quality in v1 time”, hitting OKRs earlier) even with long AI review loops.
- Others report parity or slower progress versus manual coding, but with higher final quality and more explored alternatives.
- Token cost and provider limits/outages are real constraints; people discuss cheaper models, local models, and being “token-efficient” as a skill.
Code Quality, Comprehension, and Learning
- Thread strongly emphasizes staying “aware” of all generated code and maintaining a mental model; fear of cognitive offloading and “anchoring” on AI’s first attempt.
- Opinions split on AI code quality: some say modern models beat most humans on small snippets; others find it technically correct but ugly, overengineered, or context-blind.
- Several report genuine learning: new patterns, idioms, and designs from reading AI code and arguing through trade-offs.
Skepticism and Risks
- Concerns about “slop”: large, poorly factored AI-generated code, endless review loops, and accumulating tech debt that no one truly understands.
- Worries about burnout from supervising many agents in parallel, constant context switching, and pressure to ship more with less time.
- Ethical and organizational fears: dependence on vendors, layoffs justified by AI, management pushing unsupervised agentic coding, and loss of craftsmanship and “taste.”