NeuroLint for VS Code

Deterministic code transformation for React, Next.js, and TypeScript — right in your editor

The only VS Code extension that actually FIXES your code — deterministic, rule-based transformations (NOT AI) that automatically resolve 50+ code issues across 7 progressive layers, directly in your editor.

The Problem

Modern React and Next.js development suffers from repetitive, time-consuming code quality issues:

Hydration errors — window is not defined, localStorage accessed during SSR
Missing accessibility — Images without alt text, buttons without aria-labels
Framework migrations — React 19 and Next.js 16 breaking changes require manual fixes
Outdated configurations — TypeScript and Next.js configs causing build failures
Inconsistent patterns — Teams waste hours in code review on style issues
Dependency conflicts — Package version incompatibilities block upgrades

The cost: Hours of manual fixes, delayed releases, production bugs, and developer frustration.

The Solution

NeuroLint for VS Code brings the full power of the CLI directly into your editor:

AST Parsing — Understands code structure through Abstract Syntax Trees
Pattern Recognition — Identifies anti-patterns using predefined rules
Repeatable Results — Same input always produces same output
No Hallucinations — No LLM guessing or unpredictable rewrites
Auditable — Every transformation is documented and traceable
Real-time Diagnostics — See issues as you type
One-click Fixes — Apply fixes without leaving your editor

No AI black box. Just intelligent, rule-based code fixes.

How It Works: The Orchestration Pattern

NeuroLint's critical differentiator is its 5-step fail-safe orchestration system that prevents corrupted code from ever reaching production:

Step 1: AST-First Transformation

Attempts precise code transformation using Abstract Syntax Tree parsing for deep structural understanding of your code.

Step 2: First Validation

Immediately validates the AST transformation to ensure the code remains syntactically correct and maintains semantic integrity.

Step 3: Regex Fallback (If AST Fails)

If AST parsing fails or Step 2 validation fails, falls back to regex-based transformation as a safety net.

Step 4: Second Validation

Re-validates the regex transformation with the same strict checks. No shortcuts — every transformation path must pass validation.

Step 5: Accept Only If Valid

Changes are only applied if they pass validation. If validation fails at any step, the transformation is automatically reverted to the last known good state.

┌──────────────────────────────────────────────────────────────┐
│  Original Code (Last Known Good State)                      │
│  ↓                                                           │
│  Step 1: Try AST Transformation                             │
│  ↓                                                           │
│  Step 2: Validate AST Result ✓/✗                            │
│  ├─ Valid ✓ → Step 5: Accept changes                        │
│  └─ Invalid ✗ → Step 3: Try Regex Fallback                  │
│     ↓                                                        │
│     Step 4: Validate Regex Result ✓/✗                       │
│     ├─ Valid ✓ → Step 5: Accept changes                     │
│     └─ Invalid ✗ → REVERT (no changes applied)              │
└──────────────────────────────────────────────────────────────┘

This is why NeuroLint never breaks your code — unlike AI tools that can hallucinate invalid syntax, NeuroLint's orchestration pattern guarantees every change is validated twice before acceptance.

Quick Start

Installation

Open VS Code
Go to Extensions (Ctrl+Shift+X / Cmd+Shift+X)
Search for "NeuroLint"
Click Install

Or install from the command line:

code --install-extension neurolint.neurolint-vscode

First Use

Open any React, Next.js, or TypeScript project
Open the Command Palette (Ctrl+Shift+P / Cmd+Shift+P)
Type "NeuroLint: Analyze Current File"
View diagnostics in the Problems panel
Click the lightbulb 💡 to apply quick fixes

Example Transformation

Before:

function Button({ children, onClick }) {
  return <button onClick={onClick}>{children}</button>;
}

After (one-click fix):

'use client';

interface ButtonProps {
  children: React.ReactNode;
  onClick?: () => void;
}

function Button({ children, onClick }: ButtonProps) {
  return (
    <button 
      onClick={onClick}
      aria-label={typeof children === 'string' ? children : undefined}
      type="button"
    >
      {children}
    </button>
  );
}

export default Button;

Fixed automatically: TypeScript types, 'use client' directive, aria-label, button type, exports

Features

Real-time Diagnostics

NeuroLint continuously analyzes your code as you type, highlighting issues in:

Problems Panel — Full list of all detected issues
Editor Squiggles — Inline highlighting of problematic code
Hover Information — Detailed explanations when you hover over issues

Quick Fixes (Code Actions)

Click the lightbulb 💡 or press Ctrl+. / Cmd+. to:

Apply individual fixes
Apply all fixes for a specific layer
Preview changes before applying
View documentation for each issue

Explorer View

The NeuroLint Explorer panel shows:

Summary of issues by layer
File-by-file breakdown
Quick navigation to issues
One-click fix all

Status Bar

The status bar shows:

Current analysis status
Issue count
Click to show output log

Commands

Access all commands via Command Palette (Ctrl+Shift+P / Cmd+Shift+P):

Core Commands

Command	Description
`NeuroLint: Analyze Current File`	Scan the active file for issues
`NeuroLint: Analyze Workspace`	Scan all files in the workspace
`NeuroLint: Fix Current File`	Apply all fixes to the active file
`NeuroLint: Fix Workspace`	Apply all fixes to the workspace
`NeuroLint: Toggle Diagnostics`	Enable/disable real-time diagnostics
`NeuroLint: Show Output`	View the NeuroLint output log

Migration Commands

Command	Description
`NeuroLint: Migrate to React 19`	Automate React 19 migration
`NeuroLint: Migrate to Next.js 16`	Automate Next.js 16 migration
`NeuroLint: Migrate to Biome`	Migrate from ESLint/Prettier to Biome
`NeuroLint: Simplify Code`	Reduce project complexity

Analysis Commands

Command	Description
`NeuroLint: Check Dependencies`	Check React 19 compatibility
`NeuroLint: Check Turbopack Readiness`	Analyze Turbopack migration path
`NeuroLint: Check React Compiler Opportunities`	Detect memoization patterns
`NeuroLint: Assess Router Complexity`	Score project complexity (0-100)
`NeuroLint: Detect React 19.2 Features`	Find View Transitions opportunities

Utility Commands

Command	Description
`NeuroLint: Configure Settings`	Open settings panel
`NeuroLint: Show Available Layers`	View all 7 transformation layers
`NeuroLint: Show Project Stats`	View project statistics
`NeuroLint: Validate Code`	Validate without making changes
`NeuroLint: View Documentation`	Open online documentation

What NeuroLint Fixes

7-Layer Progressive Architecture

Each layer builds on the previous, ensuring safe and comprehensive transformations:

Layer	Name	What It Fixes
1	Configuration Modernization	Updates tsconfig.json, next.config.js, package.json to modern standards
2	Pattern Standardization	Removes HTML entity corruption, console.log, unused imports
3	Accessibility & Components	Adds React keys, WCAG 2.1 AA compliance, proper attributes
4	SSR/Hydration Safety	Protects against hydration errors with client-side API guards
5	Next.js App Router	Optimizes 'use client', Server Components, import structure
6	Testing & Error Handling	Generates error boundaries, scaffolds test files
7	Adaptive Learning	Learns project patterns and enforces custom conventions

Configuration

Settings

Configure NeuroLint in VS Code settings (Ctrl+, / Cmd+,):

{
  "neurolint.enabledLayers": [1, 2, 3, 4, 5, 6, 7],
  "neurolint.autoFix": false,
  "neurolint.diagnosticsLevel": "warning",
  "neurolint.maxFiles": 500,
  "neurolint.excludePatterns": [
    "**/node_modules/**",
    "**/dist/**",
    "**/build/**",
    "**/.next/**"
  ]
}

Settings Reference

Setting	Type	Default	Description
`neurolint.enabledLayers`	array	`[1,2,3,4,5,6,7]`	Which analysis layers to enable
`neurolint.autoFix`	boolean	`false`	Automatically analyze files on save
`neurolint.diagnosticsLevel`	string	`"warning"`	Minimum severity: `error`, `warning`, `info`
`neurolint.maxFiles`	number	`500`	Maximum files to analyze in workspace
`neurolint.excludePatterns`	array	`[...]`	Glob patterns to exclude from analysis

Keyboard Shortcuts

Action	Windows/Linux	macOS
Open Command Palette	`Ctrl+Shift+P`	`Cmd+Shift+P`
Quick Fix	`Ctrl+.`	`Cmd+.`
Go to Problems	`Ctrl+Shift+M`	`Cmd+Shift+M`

You can customize shortcuts in VS Code's Keyboard Shortcuts settings.

Right-click in any JavaScript/TypeScript file to access:

NeuroLint: Analyze Current File
NeuroLint: Fix Current File

Real-World Impact

Accessibility Compliance

Scenario: Meeting WCAG 2.1 AA standards for enterprise application

Run NeuroLint: Analyze Workspace
Review issues in Problems panel
Run NeuroLint: Fix Workspace

Result: 150+ accessibility issues fixed automatically, audit-ready codebase

React 19 Upgrade

Scenario: Migrating production app from React 18 to React 19

Run NeuroLint: Check Dependencies
Run NeuroLint: Migrate to React 19

Result: All breaking changes handled automatically, smooth upgrade

Next.js 16 Upgrade

Scenario: Adopting Next.js 16 caching model and middleware changes

Run NeuroLint: Migrate to Next.js 16

Result: Middleware renamed, PPR migrated, async APIs updated, zero manual work

Why NeuroLint?

vs ESLint

ESLint identifies problems. NeuroLint fixes them. Auto-fixes accessibility, hydration errors, and framework migrations that ESLint cannot handle.

vs AI Code Tools

AI tools hallucinate and produce unpredictable results. NeuroLint uses deterministic AST transformations — same input always produces same output. Auditable, repeatable, enterprise-ready.

vs Manual Fixes

Manual fixes are slow, error-prone, and expensive. NeuroLint processes hundreds of files in seconds with zero breaking changes.

vs CLI-Only

The VS Code extension provides real-time feedback, inline diagnostics, and one-click fixes — no terminal needed. Perfect for developers who prefer a visual workflow.

Supported Languages

JavaScript (.js, .jsx)
TypeScript (.ts, .tsx)
React components
Next.js pages and components

Requirements

VS Code 1.85.0 or higher
Node.js 18.0.0 or higher (for CLI features)

Known Issues

See GitHub Issues for known issues and feature requests.

Changelog

See CHANGELOG.md for version history and release notes.

Support

Issues: github.com/Alcatecablee/Neurolint-CLI/issues
Discussions: github.com/Alcatecablee/Neurolint-CLI/discussions
Documentation: neurolint.dev
Email: clivemakazhu@gmail.com

License

Apache License 2.0

Free forever — No fees, no restrictions
Commercial use allowed — Use in your company or enterprise
Modify and distribute — Fork, customize, and share as needed
Patent protection — Includes explicit patent grant

Read the full license

Contributing

We welcome contributions from the community. Please read our Contributing Guide to get started.

NeuroLint CLI — Command-line tool for CI/CD integration
CLI Documentation — Comprehensive command reference
Website — Project homepage and demos

NeuroLint for VS Code — Deterministic code fixing. No AI. No surprises. Right in your editor.

NeuroLint