An AI harness is the code and configuration around a model that controls how it works and checks what it produces. In Claude Code, that can include project instructions, tool hooks, and scripts that test the application before you accept a change.
This matters when a frontend task spans several sessions. A localization migration, for example, can look complete while a toast still contains hardcoded English or a new route has no Arabic layout coverage. A written plan gives Claude the requirements; executable checks help you find the omissions.
This article develops a seven-layer workflow for Claude Opus in Claude Code, using a multilingual dashboard as the example. You’ll keep the plan and progress in version control, add checks at defined milestones, and use a stop hook to give Claude feedback when those checks fail.
A large task creates several opportunities for requirements to get missed:
t()” may receive less attention after many edits and a context compactionClaude Code already supports resuming previous conversations with claude --continue or claude --resume. Closing the terminal does not, by itself, erase the saved session. A progress file provides a shorter handoff that a teammate can also read.
Plan mode is useful for exploring a codebase and agreeing on an approach before implementation. You can start it with claude --permission-mode plan. For this workflow, also save the approved plan in the repository so you can review changes to it alongside the code.
The emphasis on verification follows Anthropic’s Claude Code guidance. This article organizes those practices into a workflow you can adapt to your project.
Each layer has a different role. Instructions guide the model, configured hooks run at matching events, and a person makes the final acceptance decision.
| Layer | Artifact | Purpose | How it runs |
|---|---|---|---|
| 1. Plan | harness/plan.md |
Record requirements and milestones | Read at the start of work |
| 2. Context | CLAUDE.md, milestone file lists |
Limit scope and document conventions | Loaded instructions and explicit file reads |
| 3. Formatting | format.mjs |
Format edited source files and report lint failures | PostToolUse hook for Edit and Write |
| 4. Edit controls | Permission rules, guard.mjs |
Block direct edits to protected files | Permission checks and a PreToolUse hook |
| 5. Verification | harness/checks.md |
Define the checks required at each milestone | run-checks.mjs |
| 6. Review | stop-gate.mjs, verifier subagent |
Return failures to Claude and review the diff | Stop hook plus an explicit review request |
| 7. Acceptance | harness/done.md |
Confirm release requirements | Human review and CI |
harness/progress.md records the active milestone and unresolved work. Updating it is part of the workflow; the file is only useful if it stays current.
For the example, assume a Next.js App Router invoicing dashboard built with TypeScript and Tailwind CSS, with about 30 routes and 120 components. Its interface strings are initially hardcoded in English.
The task is to add English, German, French, and Arabic using next-intl. This internationalization work includes extracting interface text into message files, making the layout work right to left, and routing date and currency formatting through a shared module.
Translations require vendor approval in this example. During development, a sync script may insert English fallbacks into the other message files, but those fallbacks must remain on an untranslated-key list. Matching keys across locales does not establish that the translations are ready to ship.
The examples below concentrate on the harness. They assume an existing application with TypeScript, ESLint, Prettier, and Playwright configured, plus project-specific localization checks.
The Node.js scripts use built-in modules; the tools they invoke still need to be installed locally. Use a supported Node.js release and record the exact model and Claude Code versions when evaluating the workflow.
Create and review the harness files before enabling the edit guard. That prevents the guard from blocking its own initial setup. The file list is:
.claude/settings.json .claude/hooks/guard.mjs .claude/hooks/format.mjs .claude/hooks/stop-gate.mjs .claude/agents/verifier.md CLAUDE.md harness/plan.md harness/checks.md harness/progress.md harness/done.md scripts/run-checks.mjs scripts/i18n-sync.mjs scripts/check-locale-parity.mjs scripts/check-literals.mjs scripts/check-logical-css.mjs e2e/routes.ts e2e/seed-ids.json e2e/pseudo-locale.spec.ts e2e/rtl.spec.ts
The sync script, static scanners, and Arabic test need implementations tailored to your application. Define them before connecting the stop gate. The excerpts here do not supply a complete dashboard or its acceptance suite.
Save the approved plan to harness/plan.md. Number the requirements so test failures and review comments can refer to them:
## Invariants - I1: Interface copy uses message keys, including JSX text, accessible labels, placeholders, image descriptions, and page titles. - I2: Every production locale has the same leaf keys as messages/en.json. - I3: Non-English messages change only through the approved sync or vendor-import workflow. English fallbacks remain marked as untranslated. - I4: Direction-sensitive layout uses logical properties. Any physical-direction exception needs review. - I5: Dates, numbers, and currency use src/lib/format.ts. ## Milestones - M1: Routing and message infrastructure. Checks: C1 to C3. - M2: Extract interface strings from routes and components. Checks: C1 to C5. - M3: RTL layout and shared formatting. Checks: C1 to C8.
List the allowed files for each milestone in the actual plan. For locale routing, follow the next-intl setup instructions for your Next.js version: newer versions use src/proxy.ts, while older projects use src/middleware.ts.
Add a test-only en-XA pseudo-locale that renders English messages with markers, such as [[Invoices]]. Generate it from the English catalog while preserving ICU message syntax, and keep it out of production routing. This makes missing message lookups easier to spot in browser tests.
Keep CLAUDE.md short enough to use during routine work:
1. Read harness/progress.md and harness/plan.md before editing. Work on the active milestone and its listed files. 2. Open a component's definition before using it. Check its actual props. 3. Add English copy to messages/en.json, then run npm run i18n:sync. Do not write translations yourself. 4. Run the milestone checks and request a verifier review. Ask for approval before advancing the milestone. 5. Record the files changed, checks run, and unresolved failures in harness/progress.md before ending the session. ## Lessons <!-- Add specific, reusable corrections here. -->
Claude Code loads project instructions from CLAUDE.md, but their presence does not guarantee compliance. Check the resulting diff and command output when accepting a milestone.
Put the following configuration in .claude/settings.json. These command examples assume a macOS or Linux shell and locally installed dependencies:
{
"permissions": {
"allow": [
"Bash(npm run i18n:sync)",
"Bash(npm run build)",
"Bash(node scripts/run-checks.mjs --milestone M1)",
"Bash(node scripts/run-checks.mjs --milestone M2)",
"Bash(node scripts/run-checks.mjs --milestone M3)"
],
"deny": [
"Bash(git push *)",
"Bash(npx vercel *)",
"Read(./.env)",
"Read(./.env.*)"
]
},
"hooks": {
"PreToolUse": [
{
"matcher": "Edit|Write",
"hooks": [
{
"type": "command",
"command": "node \"$CLAUDE_PROJECT_DIR/.claude/hooks/guard.mjs\""
}
]
}
],
"PostToolUse": [
{
"matcher": "Edit|Write",
"hooks": [
{
"type": "command",
"command": "node \"$CLAUDE_PROJECT_DIR/.claude/hooks/format.mjs\"",
"timeout": 120
}
]
}
],
"Stop": [
{
"hooks": [
{
"type": "command",
"command": "node \"$CLAUDE_PROJECT_DIR/.claude/hooks/stop-gate.mjs\"",
"timeout": 900
}
]
}
]
}
}
Review the allowed scripts before granting these permissions. A command such as npm run build can execute project code.
The permission rules match particular tool calls; they do not provide complete isolation from secrets, deployments, or indirect file access. For stronger restrictions, use an appropriately configured sandbox and keep production credentials out of the working environment.
The edit guard checks paths before Claude uses Edit or Write:
// .claude/hooks/guard.mjs
import { readFileSync } from 'node:fs';
import { relative, resolve, sep } from 'node:path';
const block = (reason) => {
process.stderr.write(`Blocked by harness: ${reason}\n`);
process.exit(2);
};
try {
const { tool_input } = JSON.parse(readFileSync(0, 'utf8'));
const root = resolve(process.env.CLAUDE_PROJECT_DIR ?? '.');
if (!tool_input?.file_path) block('Missing file path.');
const file = relative(root, resolve(root, tool_input.file_path))
.split(sep).join('/');
if (file === '..' || file.startsWith('../')) {
block('This edit is outside the project.');
}
if (/^messages\/.*\.json$/.test(file) && file !== 'messages/en.json') {
block('Use the reviewed sync or vendor-import workflow for other locales.');
}
if (
/^(e2e|scripts|\.claude)\//.test(file) ||
/^harness\/(checks|plan|done)\.md$/.test(file)
) {
block('This file belongs to the reviewed harness. Request a human change.');
}
} catch (error) {
block(`Cannot validate the edit: ${error.message}`);
}
This catches direct file edits that match the hook. Shell commands, indirect writes, and symlink handling need separate controls. Keep an authoritative copy of the check scripts and test fixtures outside the agent’s writable checkout, and use that copy for final scoring or CI.
After a permitted source edit, the formatting hook runs the project’s local tools:
// .claude/hooks/format.mjs
import { readFileSync } from 'node:fs';
import { relative, resolve, sep } from 'node:path';
import { spawnSync } from 'node:child_process';
try {
const { tool_input } = JSON.parse(readFileSync(0, 'utf8'));
const root = resolve(process.env.CLAUDE_PROJECT_DIR ?? '.');
if (!tool_input?.file_path) throw new Error('Missing file path.');
const file = relative(root, resolve(root, tool_input.file_path))
.split(sep).join('/');
if (!/^src\/.*\.[cm]?[jt]sx?$/.test(file)) process.exit(0);
for (const args of [
['--no-install', 'prettier', '--write', file],
['--no-install', 'eslint', '--fix', file]
]) {
const result = spawnSync('npx', args, {
cwd: root,
stdio: 'inherit',
timeout: 45_000
});
if (result.error || result.status !== 0) {
throw new Error(`Formatting or linting failed for ${file}.`);
}
}
} catch (error) {
process.stderr.write(`${error.message}\n`);
process.exit(2);
}
A PostToolUse failure reports a problem after the edit has happened. It does not undo the change. The milestone suite must still run against the resulting files.
To enforce I5, configure ESLint to flag direct formatting calls outside src/lib/format.ts. Include the APIs your codebase uses, such as Intl.DateTimeFormat, Intl.NumberFormat, and relevant toLocaleString() methods. A syntax rule only covers the patterns it recognizes, so review aliases and wrappers too.
Define npm run i18n:sync as a reviewed project script. It should preserve approved translations, add English fallbacks for missing keys, and produce an explicit list of untranslated or stale entries when source messages change. Have a person review key removals before the script drops translated content.
Store the checks in harness/checks.md. Each row describes an assertion the project can test; a successful command establishes only that its implemented assertions passed.
| ID | Check | Command | From |
|---|---|---|---|
| C1 | Types pass, with next-intl message-key typing configured | npx --no-install tsc --noEmit |
all |
| C2 | Lint passes, including the shared-formatting rule | npx --no-install eslint . |
all |
| C3 | Production locales have the same leaf keys as English | node scripts/check-locale-parity.mjs |
M1+ |
| C4 | The static scan finds no unapproved interface literals | node scripts/check-literals.mjs |
M2+ |
| C5 | Tested pseudo-locale routes contain no unexpected unmarked text | npx --no-install playwright test e2e/pseudo-locale.spec.ts |
M2+ |
| C6 | The scan finds no unapproved physical-direction layout rules | node scripts/check-logical-css.mjs |
M3+ |
| C7 | Tested Arabic routes set RTL direction and stay within the viewport | npx --no-install playwright test e2e/rtl.spec.ts |
M3+ |
| C8 | The production build succeeds | npm run build |
M3+ |
For C1, follow next-intl’s TypeScript augmentation setup. Running tsc alone does not give message keys stricter types. C3 should compare nested leaf paths, while C4 needs a TypeScript-aware parser and reviewed exceptions for dynamic content.
The runner below rejects an invalid milestone or an incomplete table before executing commands. Its shell commands come from a trusted, reviewed file:
// scripts/run-checks.mjs
import { readFileSync } from 'node:fs';
import { spawnSync } from 'node:child_process';
try {
const args = process.argv.slice(2);
if (
args.length !== 2 || args[0] !== '--milestone' ||
!/^M[1-3]$/.test(args[1])
) {
throw new Error('Usage: node scripts/run-checks.mjs --milestone M1|M2|M3');
}
const current = Number(args[1].slice(1));
const scopes = ['all', 'all', 'M1+', 'M2+', 'M2+', 'M3+', 'M3+', 'M3+'];
const rows = readFileSync('harness/checks.md', 'utf8')
.split('\n').filter((line) => /^\|\s*C\d+\s*\|/.test(line));
const pattern = /^\|\s*(C\d+)\s*\|([^|]+)\|\s*`([^`]+)`\s*\|\s*(all|M[1-3]\+)\s*\|\s*$/;
const checks = rows.map((line) => {
const match = line.match(pattern);
if (!match) throw new Error(`Invalid check row: ${line}`);
return match.slice(1).map((value) => value.trim());
});
if (
checks.length !== scopes.length ||
checks.some(([id, , , scope], i) => id !== `C${i + 1}` || scope !== scopes[i])
) {
throw new Error('Expected C1 to C8 in order with the reviewed milestone scopes.');
}
let failed = false;
for (const [id, description, command, scope] of checks) {
if (scope !== 'all' && current < Number(scope[1])) continue;
console.log(`Running ${id}: ${description}`);
const result = spawnSync(command, {
shell: true,
stdio: 'inherit',
timeout: 90_000
});
const passed = !result.error && result.status === 0;
console.log(`${id}: ${passed ? 'PASS' : 'FAIL'}`);
if (!passed) failed = true;
}
process.exit(failed ? 1 : 0);
} catch (error) {
process.stderr.write(`${error.message}\n`);
process.exit(1);
}
Adjust command timeouts to your suite. If you add checks, update the runner’s expected IDs and scopes in the same reviewed change.
Static analysis can miss a toast assembled in a hook or a title returned by generateMetadata. A browser test can inspect the rendered output, provided the test reaches the relevant state.
Start with a route inventory. This example discovers page.tsx files, removes route-group segments, and substitutes fixture IDs for ordinary dynamic segments:
// e2e/routes.ts
import { readdirSync } from 'node:fs';
import seed from './seed-ids.json';
const ids: Record<string, string> = seed;
const pages = readdirSync('src/app/[locale]', { recursive: true })
.map(String)
.map((file) => file.replaceAll('\\', '/'))
.filter((file) => /(^|\/)page\.tsx$/.test(file));
if (pages.length === 0) throw new Error('No route pages found.');
export const routes = [...new Set(pages.map((file) => {
const segments = file.split('/').slice(0, -1);
const path = segments.flatMap((segment) => {
if (segment.startsWith('@') || segment.startsWith('(.') || segment.includes('...')) {
throw new Error(`Add an explicit route fixture for ${file}.`);
}
if (/^\([^/]+\)$/.test(segment)) return [];
const dynamic = segment.match(/^\[([^\]]+)\]$/);
if (!dynamic) return [segment];
const value = ids[dynamic[1]];
if (!value) throw new Error(`Missing seed ID for ${dynamic[1]}.`);
return [encodeURIComponent(value)];
});
return '/' + path.join('/');
}))];
For an invoices/[invoiceId] route, seed-ids.json could contain {"invoiceId": "invoice-001"}. The seeded database must contain that invoice. Catch-all routes, parallel routes, and intercepted routes need explicit fixtures or an expanded resolver; this example stops when it encounters them.
Configure Playwright with the application’s base URL, test-only pseudo-locale, and authenticated fixtures. Each page should expose a data-testid="page-ready" element after its required data has loaded, with data-route set to its concrete, unprefixed path. That marker belongs on the expected page content, not a shared loading or error shell.
// e2e/pseudo-locale.spec.ts
import { expect, test } from '@playwright/test';
import { routes } from './routes';
for (const route of routes) {
test(`pseudo-locale text on ${route}`, async ({ page }) => {
const expectedPath = `/en-XA${route}`.replace(/\/$/, '');
const response = await page.goto(`/en-XA${route}`);
expect(response?.ok()).toBe(true);
expect(new URL(page.url()).pathname.replace(/\/$/, '')).toBe(expectedPath);
const ready = page.getByTestId('page-ready');
await expect(ready).toBeVisible();
await expect(ready).toHaveAttribute('data-route', route);
await expect(ready).toContainText('[[');
const leaks = await page.evaluate(() => {
const untranslated = (value: string) => {
const remainder = value.replace(/\[\[[\s\S]*?\]\]/g, '');
return !/^[\s\d\p{P}\p{S}]*$/u.test(remainder);
};
const visible = (element: Element) => element.checkVisibility({
visibilityProperty: true,
opacityProperty: true
});
const found: string[] = [];
const walker = document.createTreeWalker(document.body, NodeFilter.SHOW_TEXT);
for (let node = walker.nextNode(); node; node = walker.nextNode()) {
const element = node.parentElement;
if (!element || element.closest('script, style') || !visible(element)) continue;
const text = node.textContent ?? '';
if (untranslated(text)) found.push(text.trim());
}
for (const element of document.querySelectorAll('[aria-label], [placeholder], [alt], [title]')) {
if (!visible(element)) continue;
for (const attribute of ['aria-label', 'placeholder', 'alt', 'title']) {
const value = element.getAttribute(attribute);
if (value && untranslated(value)) found.push(`${attribute}="${value}"`);
}
}
if (untranslated(document.title)) found.push(`Page title: ${document.title}`);
return found;
});
expect(leaks).toEqual([]);
});
}
The page-specific assertions help detect redirects and incomplete rendering. They replace a general networkidle wait, which Playwright discourages for readiness checks.
Treat the marker scan as a heuristic. Rich text can split markers across nodes, and display: contents can affect visibility checks.
Brand names, user data, and formatted dates need reviewed fixtures or narrow exceptions. Add interactions for dialogs and toasts, then scan again; visiting a route only tests its initial state.
C7 should test the same relevant flows in Arabic at defined viewport sizes. Checking dir="rtl" and document overflow catches specific layout failures. It will still miss a reversed icon or text clipped inside a fixed-width button, so retain visual review.
A Claude Code Stop hook runs when the main agent finishes responding. The hooks reference explains how exit code 2 asks Claude to continue and how stop_hook_active identifies a continuation caused by a stop hook.
The following gate runs the active milestone’s checks. It gives Claude one repair cycle, then allows the turn to end with a recorded needs-review status if checks still fail. This bounds retries without treating an unsuccessful run as complete:
// .claude/hooks/stop-gate.mjs
import { appendFileSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
import { spawnSync } from 'node:child_process';
process.chdir(process.env.CLAUDE_PROJECT_DIR ?? '.');
mkdirSync('harness', { recursive: true });
let input;
let milestone;
let passed = false;
let detail = '';
try {
input = JSON.parse(readFileSync(0, 'utf8'));
const progress = readFileSync('harness/progress.md', 'utf8');
milestone = progress.match(/^Current milestone: (M[1-3])\s*$/m)?.[1];
if (!milestone) throw new Error('Missing or invalid current milestone.');
const result = spawnSync(process.execPath, [
'scripts/run-checks.mjs', '--milestone', milestone
], {
encoding: 'utf8',
timeout: 810_000,
maxBuffer: 5 * 1024 * 1024
});
passed = !result.error && result.status === 0;
detail = `${result.stdout ?? ''}\n${result.stderr ?? ''}\n${result.error?.message ?? ''}`;
} catch (error) {
detail = error.message;
}
const needsReview = !passed && (!input || input.stop_hook_active === true);
const status = passed ? 'checks-passed' : needsReview ? 'needs-review' : 'checks-failed';
const report = {
status,
milestone: milestone ?? null,
checkedAt: new Date().toISOString(),
detail: detail.slice(-8000)
};
writeFileSync('harness/last-check.json', JSON.stringify(report, null, 2));
if (passed) process.exit(0);
if (needsReview) {
appendFileSync('harness/progress.md', `\n- ${report.checkedAt}: ${milestone ?? 'unknown milestone'} needs human review. See harness/last-check.json.\n`);
process.stderr.write('Checks remain unresolved. This turn may end; the milestone is not accepted.\n');
process.exit(0);
}
process.stderr.write(`Checks failed for ${milestone ?? 'the current milestone'}. Inspect the failures and try to fix them.\n${report.detail}\n`);
process.exit(2);
Keep generated status files out of commits. Review harness/last-check.json when a turn ends, and require a fresh CI run before merging. A hook timeout, user interruption, or stale result can leave work unchecked; the final acceptance process must account for those cases.
After checks pass, explicitly request a verifier review. A custom subagent provides a separate working context, though it still receives its task and project instructions. It can miss the same defect as the implementation model.
Save this definition in .claude/agents/verifier.md:
--- name: verifier description: Review the current milestone against the plan after checks pass. tools: Read, Grep, Glob, Bash --- Review the current changes. Do not modify application code or acceptance tests. 1. Read harness/plan.md and harness/progress.md. Compare the working tree with the human-supplied starting commit using git diff <base-commit>, then run git status --short and inspect relevant untracked files. 2. Report PASS, FAIL, or NOT CHECKED for each invariant. Include file references and the evidence used. 3. With the seeded, authenticated test server running, capture five agreed routes in Arabic and German using the project's Playwright screenshot tests. Open the resulting images with Read. 4. Check directional icons, clipped labels, and untranslated interface text. Report anything you could not inspect. 5. For each failure, suggest an additional assertion. Request human review before changing checks.md or the test fixtures.
Supply the actual starting commit when invoking the verifier. git diff main...HEAD alone would omit uncommitted work, which is often what the agent has just produced. Bash access also means the verifier can write files despite its instructions; use a separate restricted checkout when a read-only review is required.
Save screenshots from meaningful application states, including authentication and loaded data. A screenshot of a login redirect cannot establish that an invoice page works in Arabic. Use the review findings to improve the checks or add a specific lesson to CLAUDE.md.
Keep a final checklist in harness/done.md:
Sending keys to a vendor completes a handoff. A multilingual release also needs the approved translations and a test of the imported content.
Use harness/progress.md to record the current state. The milestone line is parsed by the stop hook:
Current milestone: M2 ## Decisions - Message keys are namespaced by route, for example invoices.list.title. ## Blockers - Vendor translations are pending. English fallbacks remain in development catalogs. ## Log - Session 2: Extracted invoice-list strings. C5 found a hardcoded toast after the save action; the fix still needs verification.
Record what ran and what remains unresolved. Advance the milestone only after the required checks and review are complete.
A useful comparison starts both runs from the same application commit and uses the same feature request. Record the exact Opus model, Claude Code version, permissions, and stopping rules. Use separate worktrees so edits from one run cannot affect the other.
progress.md. Provide the same services and fixture data used by the baselineChecks that Claude reads and runs during development are visible acceptance tests. Reserve “held-out” for evaluation cases it cannot inspect. Both runs should receive the same product requirements, with the differences in feedback and automation documented.
Editorial verification pending: The submitted draft contains the figures below but does not include a repository, run logs, or the exact model version. Retain these as unverified author-reported results until the supporting records are supplied.
| Measure | Run A: Plan mode | Run B: Harness |
|---|---|---|
| Routes with untranslated text in the pseudo-locale | 9 of 30 | 0 of 30 |
| Hardcoded strings found by the static scan | Approximately 45 | 0 |
| Translation keys reportedly written by the model | Approximately 280 across German, French, and Arabic | 0; four guard blocks reported |
| Locale keys out of parity | 23 | 0 |
| Routes failing the Arabic layout check | 6 of 30 | 0 of 30 |
| Completion claims while checks were failing | 3 | No claims shown to the user; seven stop-hook blocks reported |
| Sessions and human interventions | 3 sessions; 11 interventions | 4 sessions; 3 interventions |
| Wall-clock time, including setup | Approximately 4 hours | Approximately 6.5 hours, including 1.5 hours of setup |
| Reported token usage | Approximately 5 million | Approximately 9 million |
These figures need a reproducible scoring procedure, including a definition of “intervention” and separate input, output, and cached-token counts. The hook examples in this edit have changed, so the reported measurements must not be attributed to these revised scripts without another run.
One paired run cannot establish an expected defect rate or cost saving. Repeat the comparison before making general performance claims, and distinguish fewer failures on the tested cases from complete localization coverage.
The plan records the requirements. The runner reports which assertions passed at the active milestone, and the edit guard catches a defined set of direct writes. A verifier adds a separate review of the resulting code and screenshots.
Those checks can still miss inaccessible controls, untested states, or poor translations. Evaluate the harness by the failures it detects and the effort needed to maintain it. Broader claims require evidence from the application and tasks where it is used.
The full workflow is useful for changes that span sessions and apply the same requirement across many files, such as localization or a design-system migration. It also helps when several people need to inspect the plan and understand which checks have run.
For a small change, an approved plan and the project’s existing tests may cover the work. If the task needs more support, begin with a progress file and a reviewed check runner, then add a stop hook once you understand how long the checks take and how failures should reach a person.
Revisit the configuration when the model or project changes. Keep hooks that catch recurring failures, and simplify steps that add cost without improving the checks you need.
A Claude Code harness gives a team a repeatable way to record requirements and inspect the result of an AI-assisted change. Start with one milestone whose outcome you can test, save the command output, and review what the tests missed before extending the workflow across the application.

Chema Roldán, CTO at Genially, shares how his teams have stopped watching sessions manually thanks to the LogRocket MCP.

See how JPEG XL compares with WebP and AVIF, including file sizes, decoding speed, and browser support.

Build a React research assistant with TanStack AI subagents, tool approvals, and conversation compaction.

Learn key lessons from real-world code migrations using AI coding agents.
Hey there, want to help make our blog better?
Join LogRocket’s Content Advisory Board. You’ll help inform the type of content we create and get access to exclusive meetups, social accreditation, and swag.
Sign up now