Fully Automated Code Review with Claude Code—Implementing Harness Engineering Patterns

# MyProject — CLAUDE.md
 
## Critical Rules
 
### 1. TypeScript Strict Mode Required
- Enable `strict: true` in tsconfig.json
- No implicit `any` types
- Reason: Compile-time type safety
 
### 2. Consolidate test files in src/tests/
- ❌ src/components/Button.test.tsx
- ✓ src/tests/components/Button.test.tsx
- Reason: Clear structure, unified npm test execution
 
### 3. Prohibit external library additions
Approved libraries:
- react, react-dom
- typescript
- vitest, playwright
 
Forbidden libraries:
- lodash (existing utilities suffice)
- moment, date-fns (use Intl API)
- axios (fetch suffices)
 
Reason: Bundle size control, vulnerability minimization
 
### 4. CSS via Tailwind only
- ❌ styled-components, emotion
- ✓ Tailwind className
- Reason: Eliminate CSS-in-JS runtime dependency
 
### 5. Snapshot testing forbidden
- ❌ expect(output).toMatchSnapshot()
- ✓ expect(output).toBe('expected')
- Reason: Prevent accidental snapshot updates
 
## Design Philosophy
 
### Three-Layer Architecture

npm run lint:fix  # Auto-fix linting issues

# Claude Code executes:
"Review payment.ts against CLAUDE.md rules"

# Claude Code executes:
npm run lint:fix         # Auto-fix linting
npm run type-check       # TypeScript type check
npm run test:unit        # Unit tests
npm run test:integration # Integration tests

# Auto-commit after all tests pass
git add .
git commit -m "feat: payment system - auto-reviewed by Claude Code"
git push origin feature/payment

## Definition of Responsibility
- "One responsibility = one business rule change causes cascade"
- Counts as single responsibility:
  ✓ Multiple processing steps (validation → calculation → output)
  ✗ Number of functions called (unrelated to function granularity)
 
## Acceptable Thresholds
- Function lines: < 300
- Cyclomatic complexity: < 10
- Nesting depth: < 3

## Fix Priority (No Contradictions)
1. TypeScript compile errors (non-negotiable)
2. Test failures (non-negotiable)
3. Architecture violations (must fix)
4. Style violations (recommended)
5. Comment additions (suggested)
 
Rules:
- Don't re-flag Priority 1-3 if already fixed
- Don't flag contradictory Priority 4-5 on subsequent iterations

## Step 4: Verify Checklist
- [ ] TypeScript compiles: tsc --noEmit
- [ ] Unit tests pass: npm test
- [ ] Integration tests pass: npm run test:integration
- [ ] Lint succeeds: npm run lint
- [ ] Build succeeds: npm run build
 
Don't proceed to next Correct step until all checked.

// mcp-code-review/index.ts
import Anthropic from "@anthropic-sdk/sdk";
 
const client = new Anthropic({
  apiKey: process.env.ANTHROPIC_API_KEY,
});
 
interface ReviewRequest {
  filePath: string;
  rules: string;  // CLAUDE.md content
}
 
async function reviewCode(req: ReviewRequest): Promise<string> {
  // Step 1: Read file
  const fileContent = await fs.readFile(req.filePath, "utf-8");
 
  // Step 2: Claude reviews
  const review = await client.messages.create({
    model: "claude-opus-4-1",
    max_tokens: 4096,
    messages: [
      {
        role: "user",
        content: `
You are a code reviewer using Harness Engineering principles.
 
Rules (from CLAUDE.md):
${req.rules}
 
File to review:
${fileContent}
 
Follow these steps:
1. Check each rule violation
2. Categorize by priority (Critical/High/Medium/Low)
3. Suggest fixes ONLY for Critical/High
4. For each suggestion, explain why
 
Output format:
PRIORITY: <level>
RULE: <violated rule>
ISSUE: <description>
FIX: <suggested code>
---
        `,
      },
    ],
  });
 
  return review.content[0].type === "text" ? review.content[0].text : "";
}
 
// Step 3: Triage
function triageReview(review: string): Map<string, string[]> {
  const issues = new Map<string, string[]>();
 
  review.split("---").forEach((block) => {
    const priorityMatch = block.match(/PRIORITY: (\w+)/);
    if (priorityMatch) {
      const priority = priorityMatch[1];
      issues.set(priority, [...(issues.get(priority) || []), block]);
    }
  });
 
  return issues;
}
 
// Step 4: Auto-fix
async function autoFix(
  filePath: string,
  issues: string[]
): Promise<boolean> {
  // Fix only Critical/High
  const criticalAndHigh = issues.filter((i) =>
    i.match(/PRIORITY: (Critical|High)/)
  );
 
  if (criticalAndHigh.length === 0) {
    return true;  // Nothing to fix
  }
 
  const fixPrompt = criticalAndHigh
    .map((i) => i.match(/FIX: ([\s\S]+?)---/)?.[1])
    .join("\n");
 
  const fixed = await client.messages.create({
    model: "claude-opus-4-1",
    max_tokens: 4096,
    messages: [
      {
        role: "user",
        content: `Apply these fixes to the code:\n${fixPrompt}`,
      },
    ],
  });
 
  // Step 5: Validate
  await execSync("npm test", { cwd: process.cwd() });
  await execSync("npm run lint", { cwd: process.cwd() });
 
  return true;
}
 
// Main: Max 6 iterations
async function reviewLoop(filePath: string, rules: string) {
  let iteration = 0;
  const maxIterations = 6;
 
  while (iteration < maxIterations) {
    iteration++;
 
    // Step 2: Review
    const review = await reviewCode({ filePath, rules });
 
    // Step 3: Triage
    const triaged = triageReview(review);
 
    // If no Critical/High, done
    if (
      !triaged.has("Critical") &&
      !triaged.has("High")
    ) {
      console.log(`✓ Review passed after iteration ${iteration}`);
      return;
    }
 
    // Step 4: Auto-fix
    const fixed = await autoFix(
      filePath,
      Array.from(triaged.values()).flat()
    );
    if (!fixed) {
      console.log(`✗ Auto-fix failed at iteration ${iteration}`);
      return;
    }
  }
 
  console.log(`⚠ Max iterations (${maxIterations}) reached`);
}