AI Tools in the Developer Workflow: What Actually Helps vs What Wastes Time

I've used AI coding tools daily for over a year. Not as a novelty — as a production tool. Here's what's actually worth your time.

Where AI Tools Genuinely Help

Boilerplate Generation

The highest-ROI use case. Writing Room DAOs, Hilt modules, ViewModel boilerplate, data class mappers, manifest entries — these are repetitive, pattern-based, and AI does them fast:

"Create a Room DAO for a Task entity with CRUD operations 
and a Flow query for active tasks using the existing TaskEntity class"

Result in 10 seconds. Saves 20 minutes. Repeat 10 times a day.

Code Explanation and Understanding

Encountering unfamiliar code — legacy code, third-party library internals, complex Gradle build scripts:

"Explain what this ProGuard rule does and what would break if I removed it"

Far faster than reading documentation, searching Stack Overflow, or reverse-engineering through trial and error.

Writing Tests for Existing Code

Given a function, generating the happy path, edge cases, and negative test cases:

"Write JUnit tests for this TaskService.completeTask() method. 
Cover: success case, task not found, already completed, repository failure."

The AI writes a solid test suite in 30 seconds. You review, add anything it missed, and move on.

Debugging Error Messages

Paste a stack trace or error message and get an explanation of the likely cause and fix. Works for Gradle build errors, Room migration errors, Compose recomposition issues, and more.

Where AI Tools Are Unreliable

Complex Architecture Decisions

"Should I use SharedFlow or StateFlow here?" requires context about your app's full architecture, lifecycle requirements, and what's already been established. AI will give you an answer — it may be correct for a generic case, not your specific one.

Use AI to understand the options. Make the decision yourself.

Generating Code That Integrates With Your Specific Codebase

Generic code is easy. Code that correctly uses your existing abstractions, follows your established patterns, and integrates with your Hilt graph requires the AI to understand the full context. Without that context, you get code that compiles but doesn't fit.

Provide full context: paste relevant classes, existing patterns, and be specific about constraints.

Security-Critical Code

Authentication flows, cryptographic operations, data sanitization, SQL queries. AI can generate this code but may miss subtle security issues. Always review security-critical code manually, preferably with a checklist.

Judgment Calls

"Is this the right feature to build?" "Should I add this complexity?" "Is this worth the maintenance cost?" These require understanding your users, your constraints, your strategic goals. AI can't know these.

The Claude Code Workflow I Actually Use

I use Claude Code (the CLI) rather than IDE plugins because it can:

• Read multiple files for full context
• Execute commands and see the output
• Iterate based on results
• Work with the full codebase structure

Typical workflow for a new feature:

1. Spec phase: Describe the feature, ask Claude to identify which files need to change
2. Implementation: "Add the Room DAO for this entity using the pattern in TaskDao.kt"
3. Testing: "Write unit tests for the just-created ViewModel method, using FakeTaskRepository like the existing tests"
4. Review: Read the generated code carefully — always

The review step is non-negotiable. AI code can be subtly wrong in ways that pass lint and compile.

Measuring the Real Time Savings

My honest estimate for an average day:

• Boilerplate generation: -45 min/day
• Understanding unfamiliar code: -20 min/day
• Writing test cases: -30 min/day
• Debugging Gradle/build issues: -15 min/day
• Reviewing AI output and fixing errors: +20 min/day
• Net daily saving: ~90 minutes

At scale across a month, that's ~30 hours. Significant.

The review time is real. Don't treat generated code as done until you've read every line.

The Right Mental Model

Think of AI as a senior developer who:

• Types very fast
• Knows most patterns
• Has never seen your codebase before
• Occasionally hallucinates confidently
• Can't make strategic decisions

Brief them like you would a real developer who's new to the project. Provide context. Review their output. Don't hand them responsibility — hand them tasks.

Takeaways

• Boilerplate, test generation, and code explanation are the highest-ROI use cases
• Always review generated code line by line — especially for security, architecture, and integration points
• Provide full context: paste existing patterns and constraints
• AI can't make judgment calls about what to build — only how to build it
• Net time savings are real but require discipline about when and how you use the tools