The CodeMender Agent: Google Antigravity's Self-Healing Code Feature

Google Antigravity's CodeMender agent is revolutionary: it automatically detects and fixes bugs in your codebase.

This guide shows you how to use CodeMender effectively.

What is CodeMender?

CodeMender is an autonomous agent that:
* Monitors your codebase for errors
* Analyzes error patterns
* Suggests fixes
* Applies fixes automatically (with your approval)
* Learns from your feedback

How CodeMender Works

1. Error Detection

CodeMender monitors:
* Compiler/linter errors
* Runtime errors (from logs)
* Test failures
* Performance issues

2. Root Cause Analysis

When an error is detected, CodeMender:
* Traces the error to its source
* Analyzes related code
* Identifies the root cause

3. Fix Generation

CodeMender generates multiple fix options:
* Quick fix (minimal change)
* Robust fix (handles edge cases)
* Refactor (improves code quality)

4. Validation

Before applying fixes, CodeMender:
* Runs tests
* Checks for regressions
* Verifies the fix works

Activating CodeMender

Step 1: Enable in Settings

1. Open Settings (`Cmd+,`)
2. Go to Agents > CodeMender
3. Toggle “Enable CodeMender”
4. Set approval mode:
* Manual: You approve each fix
* Auto: Fixes applied automatically (risky!)

Step 2: Configure Monitoring

Choose what CodeMender monitors:
* [ ] Linter errors
* [ ] TypeScript errors
* [ ] Runtime errors
* [ ] Test failures
* [ ] Performance warnings

Step 3: Set Aggressiveness

* Conservative: Only fix obvious bugs
* Balanced: Fix bugs and some code smells
* Aggressive: Refactor and optimize aggressively

Using CodeMender

Scenario 1: Fixing a TypeScript Error

Error:
“`typescript
const user = getUser();
console.log(user.name); // Error: Object is possibly ‘undefined'
“`

CodeMender's Fix:
“`typescript
const user = getUser();
if (user) {
console.log(user.name);
} else {
console.log(‘User not found');
}
“`

How It Works:
1. CodeMender detects the TypeScript error
2. Analyzes the code
3. Suggests adding a null check
4. You approve
5. Fix is applied

Scenario 2: Fixing a Runtime Error

Error in Logs:
“`
TypeError: Cannot read property ‘length' of undefined
at processItems (app.js:42)
“`

CodeMender's Analysis:
1. Traces error to line 42
2. Identifies that `items` is undefined
3. Finds where `items` should be defined
4. Suggests fix

Fix:
“`javascript
function processItems(items = []) { // Add default value
return items.length;
}
“`

Scenario 3: Fixing Test Failures

Failing Test:
“`javascript
test(‘calculates total', () => {
expect(calculateTotal([10, 20, 30])).toBe(60);
});
// Actual: 59
“`

CodeMender's Investigation:
1. Runs the test
2. Debugs the `calculateTotal` function
3. Finds off-by-one error
4. Suggests fix

Fix:
“`javascript
function calculateTotal(items) {
return items.reduce((sum, item) => sum + item, 0); // Was missing initial value
}
“`

Advanced Features

1. Pattern Learning

CodeMender learns from your codebase:
* How you handle errors
* Your coding patterns
* Your preferences

Example:
If you always use `try-catch` for async operations, CodeMender will suggest that pattern.

2. Batch Fixing

Fix multiple errors at once:
1. Open Mission Control
2. Click “CodeMender”
3. See list of detected issues
4. Select multiple issues
5. Click “Fix All”

3. Preventive Suggestions

CodeMender doesn't just fix bugs—it prevents them:
* “This function could throw an error. Add error handling?”
* “This query could be slow. Add an index?”
* “This component could cause memory leaks. Add cleanup?”

4. Integration with CI/CD

Run CodeMender in your pipeline:
“`yaml

.github/workflows/codemender.yml

name: CodeMender
on: [push]
jobs:
fix:
runs-on: ubuntu-latest
steps:
– uses: actions/checkout@v2
– uses: google/antigravity-codemender@v1
with:
auto-fix: true
create-pr: true
“`

CodeMender will:
1. Analyze your code
2. Fix issues
3. Create a PR with fixes

Best Practices

1. Start with Manual Approval

Don't enable auto-fix immediately. Review fixes first to build trust.

2. Use in Development, Not Production

Run CodeMender in development branches, not directly on main.

3. Review All Fixes

Even if you trust CodeMender, always review fixes before merging.

4. Provide Feedback

When CodeMender suggests a fix:
* ✅ Accept if it's good
* ❌ Reject if it's wrong
* ✏️ Modify if it's close

This trains CodeMender to be better.

5. Combine with Tests

CodeMender works best when you have good test coverage. Tests validate that fixes don't break anything.

Limitations

What CodeMender Can't Do

❌ Fix Architectural Issues
CodeMender fixes bugs, not bad design.

❌ Understand Business Logic
CodeMender doesn't know your business rules.

❌ Replace Code Review
Human review is still essential.

❌ Fix All Bugs
Some bugs are too complex for AI.

When to Use CodeMender

Good Use Cases

✅ Fixing Linter Errors
Perfect for automated cleanup.

✅ Updating Deprecated APIs
CodeMender can migrate to new APIs.

✅ Fixing Type Errors
Great for TypeScript projects.

✅ Handling Edge Cases
CodeMender can add missing null checks, error handling, etc.

Bad Use Cases

❌ Critical Business Logic
Don't let AI fix payment calculations.

❌ Security-Critical Code
Review security fixes manually.

❌ Performance Optimization
CodeMender's optimizations might not be optimal.

Conclusion

CodeMender is a powerful tool for maintaining code quality. It's not a replacement for human developers, but it's an excellent assistant for handling tedious bug fixes.

At BYS Marketing, we use CodeMender to keep our codebase clean. It saves us hours of manual bug fixing every week.

—

Want to implement self-healing code?
Contact BYS Marketing. We'll help you set up CodeMender and other AI agents.