Quadratic Review

Every organisation has a spreadsheet that runs something important and that nobody fully understands. It was built by someone who has left, it contains formulas nested five levels deep, and changing anything is a small act of faith.

That is not a discipline failure. Spreadsheet formulas are a programming language with no comments, no variable names, no functions and no way to test anything — and people build serious systems in them because the alternative required being a developer.

Quadratic's proposition is that the alternative no longer does: describe what you want, and the analysis arrives as code you can actually read.

Quadratic: A Spreadsheet That Writes Python

• AI writes formulas, Python and charts from a plain-English question about your data.
• Readable code instead of nested formulas — the site's own comparison makes the case better than any pitch.
• Connects CSVs, Excel, PDFs and live databases, so the data does not need copying in.
• Results stay a shareable spreadsheet, which is what makes the output usable by people who do not code.
• 250,000+ people claimed, at companies and universities. Operated by Quadratic Growth Inc.

Why Replace A Formula With Code?

Quadratic's homepage shows the argument directly: a nested VLOOKUP wrapped in three IFERRORs across three sheets, described as hard to read, easy to break and impossible to debug, beside the equivalent Python with a comment explaining what it does.

That comparison is doing honest work, because the criticism of spreadsheet formulas is not aesthetic.

A complex formula has no names for its intermediate steps, no way to explain intent, and no mechanism for testing a part in isolation. When it produces a wrong number, finding out why means reading it inside out.

Code has all three. Variables carry names, comments carry intent, and each step can be checked independently — which is why software engineering built its practices around code rather than around formulas.

The consequence for auditability is the real gain. A generated formula you cannot read has to be trusted; generated code you can read has to be reviewed, and reviewing is a much better relationship with a system that produces numbers people act on.

A generated formula has to be trusted. Generated code has to be reviewed — and reviewing is a far better relationship with a number people will act on.

Connecting Live Databases To A Grid

Quadratic states it brings in CSVs, Excel files, PDFs and live databases, putting your data in one place, and describes AI agents connecting to any data.

The live database connection is the most consequential of those, and the reason is where spreadsheet errors actually come from.

Most serious spreadsheet mistakes are not calculation errors. They are stale data — an export taken last month, a copy that missed the last two hundred rows, a paste that silently truncated a column.

A live connection removes that class of error entirely, because the data is queried rather than transported. It also means the analysis can be re-run rather than rebuilt, which is what makes a spreadsheet a report instead of a snapshot.

The caution is access control. A spreadsheet with a live database connection is a query interface, and it inherits whatever permissions it was configured with — so who can open the file and what those credentials can reach becomes a security question rather than a convenience one.

Where Generated Analysis Goes Wrong

The risk with AI-written analysis is not that the code fails. It is that it runs perfectly and answers a slightly different question from the one you asked.

Ambiguity is the main source. Revenue by region sounds precise and is not: recognised or booked, which date field, in what currency, including or excluding refunds. The model picks an interpretation, and the answer looks equally confident either way.

Silent data problems are the second. Duplicate rows, inconsistent identifiers, nulls treated as zero — code handles whatever it is given, and a wrong answer from clean-looking code is harder to spot than an error message.

Statistical misuse is the third. A generated comparison may apply a test the data does not support, and the chart will be beautifully formatted regardless.

The mitigation is the thing readable code makes possible: check what it actually did on a subset you can verify by hand. That is the whole discipline, and it applies equally to any generated logic — the same reason review tools like cubic exist for code humans did not write.

• Read the generated code, since being able to is the whole point.
• State the ambiguous parts of a question explicitly — dates, currency, exclusions.
• Verify against a subset you can check by hand before trusting a total.
• Prefer a live connection over a pasted export, which is where staleness starts.
• Treat the file as a query interface and control who can open it.

Shareable Results Are The Point

Quadratic emphasises shipping results in a familiar spreadsheet your whole team can trust, with shareable, repeatable outputs.

That framing matters because it is the answer to an obvious objection: if you want code, use a notebook.

The reason people do not is distribution. A notebook is a developer artefact — colleagues cannot open it, edit a number, or use it without help, so analysis done there stays with the analyst.

A spreadsheet is universally readable. Anyone can open it, change an input, and see what happens, which is why finance and operations run on them despite every technical objection.

Quadratic's position is to keep the distribution properties of a spreadsheet while replacing its worst property — opaque formulas — with something auditable. That is a genuinely good trade and it explains why the grid remains the interface.

The Jobs A Grid Should Not Take On

It is worth being clear about where this fits, because a spreadsheet with code in it is not a data platform.

It is not a warehouse. Analysis at genuine scale belongs where the data lives, and pulling millions of rows into a grid to reason about them is the wrong architecture whatever the interface.

It is not a pipeline. Scheduled transformation, dependency management and data quality testing are a different discipline, and a spreadsheet running on demand does not replace them.

It is not a BI tool. Governed metrics, consistent definitions and dashboards everyone trusts require a semantic layer, and spreadsheets are famously where consistent definitions go to diverge.

Where it fits is the enormous middle: exploratory analysis, ad hoc questions, reports that need to be shared and changed, and the work that currently happens in a spreadsheet badly. That is most analysis in most organisations.

It also does not remember what you did. Reconstructing why an analysis was built a particular way three weeks later is a recall problem rather than a data one, which is the gap continuous-capture tools such as Pieces address from an entirely different direction.

And generated code that runs in production deserves the same scrutiny as any other. Once a spreadsheet becomes a recurring report, the logic inside it is software — which is where testing tools like Promptfoo and ordinary code review practices become relevant rather than excessive.

Analysing Data In Quadratic Without Errors

Generated analysis fails quietly, which means the discipline has to be applied before you trust a number rather than after somebody questions it.

This sequence uses the readability that makes the tool worth choosing.

1. Connect the source directly rather than pasting an export.
2. Write the question with the ambiguities resolved — dates, currency, exclusions.
3. Read the generated code before looking at the answer.
4. Verify the result against a small subset you can compute by hand.
5. Add a comment explaining why the analysis was done, not just what it does.
6. Check who can open the file, since a live connection is a query interface.