Excel AI Editor

Overview

Excel files are a black box for most users — when a workbook breaks, the only recourse is usually to rebuild from scratch or hire a consultant who knows VBA and OOXML internals. Excel AI Editor opens the workbook up like a code project: every sheet, named range, chart, Power Query connection, and VBA module appears as a component you can browse, inspect, and edit. An AI agent suggests "surgeries" — targeted edits to specific components — and you approve or reject each one with a side-by-side diff.

The demo runs against a deliberately-messy sample workbook so you can see the surgery loop without uploading anything of your own.

How It Works

1. Browse the components — The left pane shows the workbook's hierarchy: sheets, named ranges, charts, VBA modules, external links, Power Query connections, and internals. Each item carries a status badge (green for healthy, amber for warnings, red for broken).
2. Pick a target — Click any flagged item (e.g., an orphan named range pointing at #REF!). The right pane shows the AI's proposed surgery with a clear before/after.
3. Diff & apply — Review the proposed XML / VBA / M-code change. One click applies the surgery and updates the live tree. Cancel and the workbook is untouched.
4. Chain surgeries — Some surgeries surface follow-ups (e.g., deleting an orphan name reveals a formula that referenced it; fixing the formula is the next surgery in the chain).
5. Export — Download the cleaned .xlsx / .xlsm. Every surgery you applied is recorded in the workbook's metadata so you can audit what changed.

Key Features

Component-Level Browsing

Treat every part of the OOXML container as a navigable component. Sheets, named ranges, defined tables, conditional formatting, data validations, charts, drawings, calc chain, shared strings, themes, styles, external links, connections, query tables, pivot caches, custom XML, and VBA modules — all inspectable, all surgically editable.

AI-Driven Surgery Suggestions

For each broken component, the AI proposes specific fixes with reasoning: "OldFY24Revenue references #REF! — its target was deleted in a prior edit. Removing the orphan keeps the named-range table clean and eliminates a class of silent calculation errors." Cost is displayed up-front. v3.2.1 cost-reduction sweep: unprotect / set-password / manual-edit / VBA add-duplicate-delete are FREE (no AI inference); single-component AI surgeries 1-3 credits; bulk-* sweeps 5 credits (down from 10); upload and decrypt are free.

Excel-like Sheets View Formatting (v3.4.3 — Tier 3)

Uploaded workbooks render in the Sheets view with their actual Excel styling: currency formats display as $1,248,000 instead of 1248000, percent formats as 21.4%, dates as 1/24/2025. Cell fills (bg color), font color, bold/italic/underline, borders (top/right/bottom/left with width + color), and alignment (h/v/wrap) all apply. Theme color references resolve through xl/theme/theme1.xml so brand-tinted cells look right even when the source workbook uses Office theme colors instead of literal RGB.

Conditional formatting evaluates at view time. CF rules from the parsed workbook walk over the visible cells and layer CF-derived styles on top of the static styles. Supported rule types in v3.4.3: cellIs (greaterThan / lessThan / equal / between / etc.), containsText / notContainsText / beginsWith / endsWith, colorScale (2-color linear interpolation), dataBar (single-color proportional fill). Formula-based rules and icon sets are queued for v3.4.4.

Demo workbook ships with a styled Summary sheet — currency formatting on the totals, bold headers, fill colors, and a green top border on Net Income — so anonymous visitors can see the renderer before signing up.

Render-only for v3.4.3. Style editing surgery (changing CF colors, adjusting number formats) is roadmapped as v3.4.4.

Multi-Module VBA Refactor (v3.5.0)

Three AI-driven templates that rewrite VBA across every affected module atomically. The biggest gap in legacy VBA tooling: renaming a procedure means hand-editing every caller, and one missed call site silently breaks a workbook. v3.5.0 closes that — the AI grounds proposals against a workbook-wide call graph (scripts/excel-pipeline/vba_callgraph.py) and apply commits all module rewrites or none.

Click "Refactor across modules" at the VBA category header (visible when ≥2 modules):

• Rename procedure (creative, 5 cr) — pick a procedure, name its replacement, AI rewrites the declaration + every call site across every module. Handles bare calls (Foo arg), paren calls (Foo(arg)), qualified calls (Module1.Foo), and the legacy Call Foo(arg) syntax. Property Get/Let/Set declarations sharing a name rename as a unit.
• Move procedure (advanced, 3 cr) — pick a procedure + source + target module. The AI removes the proc from source, appends to target, and rewrites every module-qualified reference (Module1.Foo → Module2.Foo). Bare calls auto-resolve via VBA's global proc lookup.
• Replace deprecated API (creative, 5 cr) — supply the old API + a replacement pattern (or let the AI suggest one). Pattern-based rewrite across modules. Overly-complex chained accesses get a TODO: manual review comment instead of risky auto-rewrites.

Atomicity is the headline guarantee — the Python dispatcher snapshots the VBA project before the loop and rolls back on any failure. AI proposals are validated for cross-module self-consistency before apply.

Demo workbook ships 5 VBA modules with cross-module calls (Calculations, ReportBuilder, Dashboard, Helpers, DocumentationMacros) plus 3 scripted fixtures so anonymous visitors can preview the rename / move / replace-API surgeries without uploading.

Sheet-Level Ops + Table Reformatting (v3.4.1)

Six new FREE deterministic surgeries that don't invoke AI — they round-trip through the OOXML directly. Every sheet item surfaces a "Sheet ops" panel with six buttons:

• Rename — updates xl/workbook.xml AND rewrites every formula reference to the old sheet name across cells, defined names, and chart <c:f> formulas. Handles both quoted ('Sheet With Space'!A1) and unquoted (Sheet1!A1) reference forms. Enforces Excel's name rules (≤31 chars, no \ / ? * [ ] :).
• Hide / Show — sets <sheet state="hidden"> or "veryHidden". The applier refuses to hide the only visible sheet (Excel requires at least one visible).
• Move… — moves the <sheet> element to a 0-indexed target position within <sheets>. Sheet order in the tab strip updates immediately.
• Duplicate — clones the sheet's cells under a new name. Tables / drawings / charts are NOT cloned — the duplicate gets a clean rels file with just the shared parts (sharedStrings, styles). Acceptable behavior for "I want a copy of the data layout" without dragging shared references along.
• Tab color… — sets or clears <sheetPr><tabColor rgb="...">. Accepts 6 or 8 hex chars (pads to ARGB). Useful for color-coding sheet groupings (Quarter / Region / Department).
• Convert range to Table… — promotes a plain A1:D10 range into a proper Excel Table (ListObject). Writes a new xl/tables/tableN.xml with autoFilter + tableColumns + a default TableStyleMedium2 stripe pattern; auto-infers column names from the first row (resolves sharedStrings) or accepts an explicit list. Adds the sheet → table relationship + <tableParts> entry + Content Types Override.

A new Tables tree category surfaces existing ListObjects in the workbook with their column count, host sheet, and range. Currently inspection-only — editing existing tables (renaming columns, swapping styles) is on the v3.4.1.x roadmap.

All six are FREE — no AI inference, no credit charge. Audit trail still records tier="free" so the in-workbook audit.xml distinguishes FREE applies from paid.

Conditional Formatting + Data Validation Surgery (v3.4.0)

The CFO audit identified two of the most common silent-breakage classes Excel doesn't surface clearly: stale conditional formatting rules (thresholds set against numbers that have since moved) and stale data validation dropdowns (Q1-Q4 lists that haven't kept up with new reporting periods like H1/H2/YTD). v3.4.0 adds first-class surgery for both.

Each rule shows up in its own tree category with sqref + criterion preview. Disable (FREE) makes the rule structurally present but inert — CF rules get their formula rewritten to FALSE, DV rules get type="none" with cleared formulas. Reversible by editing. Delete (FREE) removes the rule + cleans up the empty container element. Ask AI to Edit (3 credits, advanced tier) proposes new criteria — useful when CF thresholds need to track moved baselines, when DV dropdown sources need expansion, or when formula references need rewriting after upstream changes.

Demo workbook ships scripted fixtures for all three actions on both rule types so anonymous visitors can see the feature surface before signing up.

Side-by-Side Diff Preview

Before any change is applied, see the exact XML / VBA / Power Query M difference. No black-box edits. Apply with one click; cancel keeps the workbook untouched.

Surgery Chaining

Many fixes surface follow-up problems (e.g., deleting a name reveals a formula that referenced it). The AI proposes the next surgery in sequence so you can clean up in order rather than chasing breakage.

Relationship View — Direct / Secondary / Tertiary (v3.0.0)

Every component you click now has a Relationships tab in its detail panel that lists every other component referencing it — Direct (1°), Secondary (2°), and Tertiary (3°). Hover the inline 1°/2°/3° chips that appear on tree rows to see exactly why two components are related: "Cell references named range — via =SUM(ArchivedTaxRate)", "VBA calls VBA — via Call ProcessOrders". Click View as graph to open a full force-directed visualization of the dependency network across sheets, named ranges, charts, drawings, external links, connections, query tables, VBA modules, and Power Query queries. Confident edges (formula references, explicit VBA Call statements, chart series formulas) render solid; heuristic edges (VBA source identifier matches, M-code query mentions) render dashed amber so you can verify before acting. Surgeries no longer surprise you: you see the cascade radius before you click apply.

Cascade-into-Surgery (v3.0.1)

The Relationship view doesn't just show the cascade — it acts on it. When you propose a fix on a component with downstream dependents, the diff modal now shows an "Also affects N other components" footer listing each downstream-affected component with an opt-out checkbox. Structural fixes (named-range cleanup, external-link strip, connection strip, formula fix) auto-check the cascade items so the AI's primary fix lands alongside coordinated downstream fixes; content fixes (VBA rewrite, chart edit, Power Query edit) show the cascade but default-off so you opt in. Click "Just this one" to unselect everything in a single click. Apply orchestrates the primary fix first, then sequentially applies each accepted follow-up at the bulk rate (2 credits each). Bulk Repair gets an "Include cascade" toggle that defaults ON and expands every flagged item with its confident-edge dependents up to 30 total targets in a single LLM call. The Excel-corruption-on-next-open pattern that motivated this entire arc is gone: fixes now propose their full footprint before you commit to anything.

In-Workbook Audit Trail (v3.1.1) — SOX compliance unlock

Every fix you apply is now recorded inside the workbook itself, not just in our server logs. The downloaded .xlsx/.xlsm carries a complete change log so a colleague, auditor, or compliance reviewer can open the file and see exactly what changed. Two surfaces: (1) Excel's standard Properties pane (File → Info → Properties) shows "Last Modified By: Excel AI Editor (SkillEra.IO) (your email)" with a fresh modified timestamp and revision counter — visible without any custom tooling. (2) A dedicated customXml/audit.xml part inside the file carries the full per-fix log: timestamp, fix type, target component, tier, credits charged, your email and account ID, the AI's explanation, and the exact before/after content. For SOX-style financial-controls reviews this means your workbook is self-documenting: no separate audit-log handoff, no "what did you actually change?" follow-ups. As far as we're aware, no competing tool (Office Scripts, xlwings, ExcelGPT, Power Automate) embeds an in-file change log this way.

Workbook Diff Viewer (v3.2.0)

Every successful fix produces a versioned snapshot of your workbook (v1, v2, v3...). A new Version history strip between the toolbar and the component tree lists every snapshot with its fix type, target, timestamp, and credit cost. Click the ↕ vs vN-1 button on any row to instantly compare against the previous version, or flip into Pick two to compare mode to diff any two versions in your history. The fullscreen diff modal organizes changes into four tabs: Cells (per-sheet, value + formula side-by-side with red/green/amber color coding), Named Ranges (added/removed/modified with before-after refs), VBA Modules (unified line diff inside each module's collapsible drawer), and Charts (title + series-count changes per chart part). Server-side caching means the first compare against a given pair takes a few seconds; subsequent compares are instant. This is the workbook-level diff you've always wanted but Excel itself never gave you — no competing tool (Office Scripts, xlwings, ExcelGPT, Power Automate) ships one either.

VBA Module Round-Trip (v1.4)

For workbooks with macros, the AI can rewrite VBA modules — fix compile errors, replace deprecated APIs, modernize syntax — and the modified .xlsm opens cleanly in Excel without auto-repair dialogs. v1.4 added full CFBF mini-stream resize so the new source can grow or shrink arbitrarily (was previously capped at same-or-smaller byte length).

Power Query M-Code Editing (v1.0 + v1.6)

Power Query connections that point at missing CSVs or have stale URLs can be repointed or stripped (v1.0). As of v1.6, the AI can also rewrite the actual M-code text — change filter conditions, add new transformation steps, restructure pipelines — by parsing the DataMashup blob, swapping Section1.m content, and recompressing. Targeted per-query rewrite preserves other queries in the same workbook.

Bulk Surgery Sweeps (v1.2 + v1.4.x)

One ⚡ Sweep button per category replaces N individual surgeries with a single bulk pass: sweep every orphan named range (v1.2), every external workbook reference + connection (v1.4.x), every empty VBA module (v1.4.x — auto-detects modules with no Sub/Function declarations, removes them with proper dir + PROJECT stream cleanup). Reference-aware — won't delete a named range that's still used by a cell formula.

Workbook Format Support

Upload .xlsx or .xlsm workbooks (macro-enabled included). .xlsb Excel Binary Workbooks aren't accepted yet — Save As .xlsx or .xlsm in Excel before uploading. Native BIFF12 binary surgery is on the roadmap; until then the upload route returns a clear "Save As .xlsx" prompt so you never hit a silent failure mode.

Component Source Preview + Manual Editing (v2.1)

Every component now shows its actual XML / VBA / M / JSON source content in the details pane — see what you're about to edit before clicking anything. A new Edit manually mode lets you skip the AI step entirely: edit the raw source in a textarea, click Apply. Server-side dispatch routes VBA module rewrites + Power Query M-code edits through the existing handlers (other component types fall back to the AI surgery flow with a v2.1.x expansion note).

AI Workbook Review (v2.1)

A new AI workbook review button at the top of the workbook view kicks off a free-to-propose cross-component analysis. The AI sees the entire parsed tree + your plain-text intent ("focus on broken external links + #REF! formulas, skip cosmetic chart tweaks") and proposes up to 10 targeted surgeries spanning sheets / named ranges / charts / VBA modules / connections. Each recommendation gets an Accept button that opens the standard diff modal pre-populated with the AI's suggested intent. Free propose, per-recommendation pricing on apply. Advanced-tier feature.

Excel-Like Spreadsheet View + Direct In-Grid Editing (v2.1 + v2.2)

Click any worksheet → see an Excel-like grid with column letters, row numbers, a cell-info bar showing the focused cell's A1 ref + value + formula tooltip, and broken-formula highlighting (#REF! / #DIV/0! styled rose-bold). v2.2 promotes the grid from demo-only-read-only to production read-write. Upload any .xlsx/.xlsm → parse.py extracts the actual cells (up to A1:Z50 per sheet) → the grid renders real data. Double-click any cell to enter edit mode → type a value or formula (e.g., =SUM(A1:A10)) → Enter to commit (FREE since v3.2.1 — was 1 token/edit). Escape cancels. Gated to Advanced mode for paid users; demo mode always editable for the local preview.

Universal Manual-Edit Pipeline (v2.2)

The Manual Edit pane on every component now actually works server-side for every component type. v2.1 routed VBA modules + Power Query M-code through their existing rewrite handlers; v2.2 adds: cell-level edits (single-cell <c> mutation, formula / value / delete), named ranges (update or delete defined names), charts (full XML replacement), external links (full part replacement), connections (full part replacement). No more "supported component type" gaps — the entire workbook is now manually editable.

.xlsb Formula-Rewrite Code-Complete (v2.2 BETA)

The v2.0 BETA Ptg compiler now has its full BrtFmlaNum record emitter wired into the apply pipeline with the v1.5.x atomic dependent-part updates (binaryIndex shift + calcChain entry handling). Gated behind PTG_FULL_INTEGRATION=1 env flag pending Excel-COM verification round-trip; once verified, defaults flip on in v2.3 and the Ptg compiler graduates to GA. This closes the last major binary-format gap — .xlsb workbooks will have parity with .xlsx for formula-rewrite.

Multi-File Batch Processing (v1.7 + v1.8 + v1.9)

Drag-and-drop up to 10 workbooks at once. v1.7 ships three mechanical bulk surgeries — orphan named-range cleanup, external-link strip, empty VBA module removal — applied uniformly across the set. v1.8 adds an AI-per-file mode: type one intent ("fix every formula returning #DIV/0!" or "rename all VBA Subs to PascalCase") plus a surgery type, and the AI inspects each workbook's tree to propose a tailored diff per file. Review every proposal in a stack with per-file accept/reject (or "Accept all"), then apply only what you trust.

v1.9 rounds out the workflow with four iterative-control features:

• Regenerate: any proposal can be re-rolled with optional guidance ("try without VBA", "use named-range removal instead"). Free, capped at 30 regenerations per batch.
• Override → mechanical: swap any AI proposal for a mechanical bulk surgery on just that file — useful when the AI's tailored diff is overkill for a file that just needs a generic sweep.
• Automatic partial-failure refunds: if N of M files fail after applying, the failed files' credits are refunded to your balance automatically. No support ticket needed.
• VBA module rewrite in AI per-file mode: the AI can now propose tailored VBA module rewrites per file (advanced tier, 3 tokens/file — re-tiered in v2.4 from creative 5 → advanced 3 since the surgery now emits a structured response).
• v2.4 — free to propose, pay on apply: single-component AI proposals + conversational refinement turns are free. Tokens charged only when you Apply.
• v2.4 — refinement chat: spot a flaw in the AI's proposal? Type a critique in the diff modal, AI revises. Pick any version (v1/v2/v3…) from the tab strip and Apply commits that one.
• v2.4 — workbook version tagging: explicitly mark meaningful versions of your cleaned workbook. Tagged jobs retained 7 days; untagged 24 hours.
• v2.4 — CodeBehind safety guard: bulk VBA cleanup refuses to remove ThisWorkbook / Sheet* / UserForm* / Form* / frm* modules even when blank, protecting against accidental workbook corruption.
• v2.5 — Cross-reference awareness: every AI surgery now sees workbook-wide context (other VBA module heads, named ranges, sheet names, Power Query modules) and is explicitly instructed to preserve cross-references when refactoring — prevents silent dependency breaks where a fix to module A would silently rename something module B calls.
• v2.5 — Repair all flagged with AI: category-level batch button queues per-module AI repair with auto-advance. Review each proposal individually, Apply / Skip / Stop-batch. Each Apply charges the per-tier cost (3 credits for vba-rewrite); refines + proposals stay free.
• v2.5 — Holistic workbook AI review: the workbook-review AI now reasons about cross-component patterns (duplicate function consolidation, caller-callee chains, named-range references). Recommendations surface affected callers so users understand the full scope before applying. v2.4.2 — Modify healthy components: any working component can be modified via AI (refactor, extend, rename, change behavior), not just flagged ones.
• v2.6 — Per-query Power Query tree: M-code modules with multiple queries now expand as a collapsible tree with one row per query. Click a query name to inspect just that query's code in the right pane. AI surgery on a single query auto-scopes the change to that query — other queries in the same module are left untouched.
• v2.7 — VBA component management: three new structural surgeries — Add Module (Standard or Class), Duplicate Module under a new name, and Delete-Single Module. Authors directly into xl/vbaProject.bin (CFBF stream + MS-OVBA dir-stream MODULE block + PROJECT/PROJECTwm sync). Mechanical — no AI step, no propose/refine loop. Pricing as of v3.2.1: all three are FREE (were 3-5 credits — moved to free tier in v3.2.1 since no AI is invoked). Document modules (sheet code-behind) protected against deletion. UserForm creation queued for v2.7.1 (requires FRX designer-stream authoring).
• v2.8 — Visual chart rendering: parse.py now emits a structured ChartSpec for every xl/charts/chart*.xml part at parse time — chart type, title, axis labels, per-series categories/values/colors. Widget renders the chart live with Chart.js v4 in the right pane (lazy-loaded, ~150KB only when a chart is viewed). Covers bar/column, line, area, pie/doughnut, scatter, bubble, radar, plus combo charts that mix series types. Unsupported chart types (3D surface, modern Office 2016 charts) fall back to the source XML view with a workaround notice. Uses Excel's own <c:numCache> for instant rendering when present; resolves <c:f> formula references against parsed sheet cells when the cache is missing.
• v2.7.1 — Class deletion + UserForm creation: closes the v2.7.0 carry-forwards. Class modules can now be deleted via vba-delete-single (same flow as Standard modules, with PROJECT-stream Class= vs Document= discrimination preventing accidental sheet code-behind removal). UserForm creation ships as EXPERIMENTAL — authors the MS-OVBA FormDataStream (f), SiteData (o), designer storage substorage at CFBF root, and inserts an MSForms 2.0 typelib REFERENCECONTROL into the dir stream. Excel may show a "found a problem" repair dialog on first open if the FormHeader fields don't match its expectations; verify the downloaded workbook in real Excel before distributing.
• v2.8.1 — AI chart-edit visual diff: when the AI proposes a chart-edit surgery, the diff modal now renders both the BEFORE chart and the AI's proposed AFTER chart side-by-side via Chart.js, alongside the existing XML diff. Client-side TypeScript parser ports parse.py's ChartSpec extraction so the proposed XML renders instantly without a server roundtrip. See the visual impact of every chart edit before clicking Apply.
• v2.8.2 — Chart PNG snapshot: every chart preview now has a "↓ Download PNG" button that renders the same ChartSpec via matplotlib in a Vercel Sandbox and downloads a high-fidelity PNG. Free — no per-render credit charge. Useful for embedding chart snapshots in reports, docs, or emails. Closes the last v2.8.0 carry-forward; v2.8 is now feature-complete.
• v2.5.6 — Encrypted-upload decrypt fix: root-causes and fixes the v2.5.5 "bad zip after decrypt" reports. The bug wasn't an msoffcrypto-tool gap as initially diagnosed — it was the decrypt pipeline piping binary bytes through stdout, which Vercel Sandbox's stdout-capture round-trips through a string causing non-ASCII bytes to corrupt. Switched to file-based I/O (matching the proven pattern from apply_surgery + render_chart_png), added explicit ZIP-signature pre-validation in decrypt.py so unsupported encryption variants surface with specific classification ("CFBF/OLE2 file — likely legacy .xls" vs "random bytes — encryption variant unsupported") instead of falling through to a generic parse error. Defense-in-depth ZIP-signature check on the Node side too.
• v2.5.7 — P0 download-corruption fix + UI polish: critical bug fix from real user testing. After stripping external links + connections, the downloaded .xlsm triggered Excel's "We found a problem with some content" recovery dialog. Root cause: surgeries removed XML part files but didn't update [Content_Types].xml, leaving orphan <Override> entries that fail Excel's structural validator. Also dropped paired _rels/*.xml.rels files, cleaned up dangling sheet-level relationship entries pointing at deleted query tables, and stripped <tableParts> references from sheet XMLs. The downloaded workbook now opens cleanly with no recovery dialog. UI polish in the same release: reorganized the Components panel header so the "Group by sheet" toggle has its own row alongside the panel title (no longer crammed with the All/Issues filter pills); patched the VS Code Dark theme to use a brighter token palette for better contrast on brown-tinted surfaces; new Small/Medium/Large font-size picker in the view-settings panel for all code panes.
• v2.5.8 — P0 continued: calcChain + stale [N] ext-refs: even after v2.5.7 fixed the manifest, Kris's second test still triggered the repair dialog. Three remaining structural triggers identified and fixed: (1) xl/calcChain.xml was stale, referencing formula cells that became #REF! after external-link removal — now dropped entirely (Excel rebuilds on save). (2) Sheet cell formulas with [N]Sheet!A1 external-reference prefixes were dangling after the externalReferences block was removed — now scrubbed to #REF! literals. (3) Workbook-level <definedName> formulas with the same [N] pattern — now scrubbed the same way. Verified end-to-end with a synthetic injection test.
• v2.5.9 — P0 third pass: dangling calcChain rel + drop <f> element entirely: Kris's v2.5.8 retest still triggered the repair dialog. Excel's recovery log pinpointed: "Removed Records: Formula from /xl/worksheets/sheet14.xml part". Two specific gaps fixed: (1) _drop_calcchain was leaving a dangling <Relationship Target="calcChain.xml"> in xl/_rels/workbook.xml.rels after deleting the file — now drops the rel too. (2) Scrubbing replaced formula content with #REF! but kept the <f> element — Excel still tried to evaluate it against the cached <v> and flagged the mismatch. Now matches Excel's own "Break Links" behavior: REMOVE the <f> entirely and keep just the cached <v> value as a static literal. Bonus: regex coverage expanded to also catch '[N]Sheet'! (full quoted path) and [N]!NamedRef (sheet-less defined name) variants.
• v2.9 — Bulk AI Repair + Workbook-Review Accept-All: closes the bulk-repair backlog with the user's token-efficiency insight built into the architecture. Single LLM inference now processes every flagged item at once instead of N independent calls — ~80% token savings, passed to users as a bulk-rate discount (2 credits/applied item, down from 3 advanced). Two entry points at the top of the widget: "Review all" opens a paginated modal with diffs grouped by AI-detected similarity pattern (e.g. "Formulas referencing OldSheet"). "Guided" walks through similarity groups one at a time with accept-all-per-group. Per-item + global accept/skip controls; cross-component dependency notes surfaced inline. Workbook Review's recommendation cards gain two improvements too: an "Accept all (N · cost)" button funnels every recommendation through the bulk pipeline in one shot, and each card has a "Revise" toggle that opens an inline textarea pre-populated with the AI's suggested intent — tweak it before clicking apply without re-running the full review.

Each file parses in its own Vercel Sandbox in parallel; orchestrator fans out applies with a 5-parallel concurrency cap. Single ZIP output with manifest.json audit trail (per-file outcome, applied parts, output size). Hard cap: 10 files, 50 MB per file, 200 MB total. Pricing (v3.2.1): mechanical bulk batches 5 tokens/file (was 10 — retiered premium → creative); AI-per-file 1 token/file (basic surgeries) or 3 tokens/file (advanced surgeries — includes VBA after v2.4 re-tier). Upload + propose + regenerate are free — credits charge only on apply. Mixed-mode batches charge each file at its exact tier cost; batches that contain only free surgeries (e.g., manual-edits across N files) cost 0 total.

Use Cases

• Financial Analysts — Inherited workbook with broken external links, ghost named ranges, and VBA macros that don't compile. Surgery in minutes instead of days of cleanup.
• Operations Managers — Recurring workbooks where Power Query connections rot when source files move. Repoint without rebuilding.
• Consultants — Take any client workbook, sanitize it (strip credentials, broken connections, dead VBA), and hand back a clean version. v1.7 batch mode lets you process an entire delivery folder in one pass and download a single audit-trailed ZIP.
• Auditors — Surface every defect in a workbook (broken refs, orphan names, untrusted external links) as a structured report.

From Demo to Production

The demo is deliberately scripted: a curated workbook + pre-canned surgeries. The Tool tier accepts your own .xlsx or .xlsm (50 MB cap), parses it server-side via an isolated Vercel Sandbox + Python pipeline (oletools + lxml + openpyxl), and proposes real AI-generated surgeries against your actual components. .xlsb binary workbooks aren't supported yet — Save As .xlsx in Excel before uploading. Workbooks are processed in isolated sandboxes, never stored long-term, and auto-purged after 24 hours. Credits per surgery, charged only on successful apply (no subscription required) — see pricing on the Tool page.

Real-World Challenges

Cost Estimates (v3.2.1 cost-reduction sweep)

ROI Definition

• Primary metric: Time saved per workbook cleanup (typically 2–8 hours of manual VBA + Power Query + Name Manager work → 5–15 minutes of guided surgeries)
• Secondary metric: Confidence — every change is diff-previewed, so you know exactly what's being modified
• Concrete example: A finance team inheriting a 50-tab consolidated model with 30 orphan named ranges, 5 broken external links, and 3 non-compiling VBA modules can clean it up in under 30 minutes instead of a half-day of consultant time

Technology Stack

Want This for Your Business?

SkillEra can deploy a customized version with your team's preferred surgeries, audit logging, integration with your file-storage platform (SharePoint, Google Drive, S3), and team-specific approval workflows.

Typical deployment timeline: 1–3 weeks for customization (the core demo + Tool pipeline is already production-grade)

Schedule a Consultation →