We recently surveyed our engineering team about their experiences working with AI coding assistants. The responses were eye-opening – while everyone agreed that AI has transformed how they build software, the approaches that actually work in practice are quite different from what you might expect.
The engineers who've found the most success aren't those who've mastered prompt engineering or discovered secret AI techniques. Instead, they've learned to structure their development process in ways that amplify AI's strengths while mitigating its weaknesses. They've developed workflows that turn AI from a sometimes-helpful assistant into a reliable development partner.
We've compiled their best insights here – 10 practical tips that can immediately improve how you build with AI. Whether you're shipping your first AI-assisted feature or leading a team that's been using these tools for months, these strategies will help you build better, more maintainable projects faster.
Before touching any AI tool, create a step-by-step roadmap. Break your feature into checkpoints: data model defined, API endpoints created, UI components built, tests passing. Each checkpoint should be verifiable – either it works or it doesn't.
Start your AI chat like this:
The AI helps you think through edge cases: token refresh, session management, error states. You're not asking for code yet – you're building a shared mental model. Next prompt might be:
This turn-by-turn approach builds a comprehensive spec, not a half-baked implementation.
Pure components with centralized state aren't just good practice – they're essential for AI-assisted development. When state is scattered across components, AI fixes create new bugs. You've seen this: fix the dropdown, break the form. Fix the form, break the validation.
Example: Instead of letting AI generate components with useState everywhere, define your auth state shape first:
Pick Redux, Zustand, MobX – doesn't matter. What matters: auth state changes happen in one place. When AI generates a fix for session refresh, it modifies a single auth reducer, not scattered useEffect hooks across your app.
Data structures determine whether your codebase scales or strangles itself. When you let AI generate code without type constraints, it invents its own data shapes – inconsistent, implicit, impossible to refactor.
Start every feature by defining your types:
Now when you prompt:
…the AI works within your constraints. It can't invent a different token structure or skip error handling you've defined. Types become your architectural guardrails.
Most AI-generated tests are worthless. They test that setUser was called, not that your auth flow actually works. The problem: AI mimics test patterns it's seen – mocking everything, asserting on internals, creating brittle suites that break with every refactor.
Instead, prompt for invariant testing:
These tests survive implementation changes. Whether you use Redux or Zustand, fetch or axios, the invariants remain.
AI momentum is dangerous. It generates plausible code quickly, you see green tests, and you keep prompting. Three hours later, you've built a castle on sand.
After each significant feature, force a hard stop:
Experienced engineers can smell AI-generated code that's been allowed to run wild. Keep it on a short leash.
Good prompt:
Result:
Start every feature with error boundaries:
Prompt:
Create a CONTEXT.md file for your current work:
Start each session by having AI read this file. When switching between features, update it.
Build comprehensive logging from the start:
This means:
The teams thriving with AI aren't writing better prompts – they're building better systems. Systems where each piece has a clear purpose, where tests define behavior, where documentation captures decisions. When the next model generation arrives, these codebases will leap forward while others struggle to explain their tangled state to even smarter AI.
Source: https://www.civic.com/news/tips-for-ai-assisted-development