Most developers use AI to write code. Fewer use it to check code. That's the gap worth closing. I've been using a few lightweight habits that have made a real difference to my daily workflow - not by adding overhead, but by replacing the tedious parts of review, fixing, and committing. Here's what actually stuck.
Review a PR
Code review is valuable but easy to skip when you're in a rush. AI won't replace a teammate's review, but it's always available, never tired, and catches the boring-but-costly stuff fast.
The setup: use any AI coding agent (I'm using CommandCode), navigate into your project, start a session:
cd my-project && cmd
Then just say:
review this pr
That's it. No need a complex prompt. It reads the diff from your current PR and comes back with a review - flagging syntax issues, type hint gaps, missing return types, inconsistent naming, and other things that are easy to miss when you've been staring at the code for hours.
If you haven't pushed a PR yet, this works just as well:
review changes in this branch
One important habit: always start a fresh session before reviewing. If you've been using the same session to write code, the model carries that context into the review - which can make it less critical and more likely to miss things. Exit the session first, then start a new one to review. For an extra layer, try coding with one model and reviewing with a different one. Different models catch different things.
Fix obvious bugs without touching your logic
This is probably the most useful single prompt I've found. After finishing a feature or a fix, I run:
Find obvious issues and fix them without changing logic
The key phrase is "without changing logic" - it tells the AI to stay in its lane. You're not asking it to refactor or improve your approach. You're asking it to act like a spell-checker: find the dumb mistakes you overlooked and fix them quietly.
It typically catches things like:
- Null/undefined not being handled
- Missing return statements
- Wrong variable names (copy-paste leftover)
- Type mismatches in function arguments
- Unused variables or imports
These are the kinds of bugs that would pass a quick eyeball review but blow up in staging. Having AI do a sweep before you push takes about 10 seconds and saves real debugging time later.
Let AI write your commit messages and open PRs
If you have gh (GitHub CLI) installed, the AI agent has everything it needs to handle the Git ceremony for you. Instead of writing commit messages and PR descriptions yourself, just tell it:
commit these changes
or
create a pr
The AI reads your diff, understands what changed, and writes a proper commit message - descriptive, consistent, and actually useful for git log. No more fix stuff, wip, or final final v2 commits.
For PRs, it'll draft a title and description based on what the changes actually do. This is genuinely helpful if your team does async reviews - a clear PR description means reviewers spend less time figuring out context and more time giving useful feedback.
Prerequisites: Install GitHub CLI gh and make sure you're authenticated gh auth login. CommandCode will use it automatically once it's available on your PATH.
None of these are groundbreaking in isolation. But they add up: you review more consistently, catch more bugs before push, and spend less mental energy on repetitive Git tasks. The best workflow changes are the ones that lower friction enough that you actually do them - and these clear that bar easily.
Give them a try and see what sticks.
