I Wasted Hours Picking LaTeX Packages. Then I Tried Asking an AI That Reads My Project

Every LaTeX user has been there.

You want to do something — display source code, format a theorem, draw a diagram — and you know a package exists for it. But which one? There are always three or four candidates, and they're all slightly different. You open the CTAN docs, they're 80 pages long. You search Stack Overflow, you find a thread from 2011 where three people recommend three different things and the accepted answer says "it depends."

Thirty minutes later you've committed to one package without really understanding why, and you're already second-guessing yourself.

This was my life for most of my master's thesis. Then I started using TeX64, a local-first LaTeX editor for macOS, and specifically its AI assistant called Axiom. And the "which package?" problem basically disappeared.

The specific problem with package discovery

The issue isn't that documentation is bad. It's that when you're trying to pick a package, you're asking a comparative question: "Given that I want to do X, and given what's already in my project, which option fits best?"

That question doesn't have a good answer in a single package's documentation. You need someone who knows the whole ecosystem, knows your context, and can give you a recommendation with a reason.

Google can get you close, but it gives you generic advice. Stack Overflow threads are either too general ("use whatever you like!") or too specific to someone else's setup. CTAN is comprehensive but not opinionated.

What I wanted was something like asking a more experienced co-author: "Hey, which package would you use for this?"

What Axiom does differently

Axiom is the AI assistant built into TeX64. What makes it actually useful for package selection is this: it reads your entire project before responding. Not just the file you have open — all your .tex files, your compile log, your .bib file.

So when you ask "which package should I use for X?", it answers in the context of your actual setup. It knows what you've already loaded, what your document class is, what errors you're getting.

Here's an example. I was writing a paper and wanted to add algorithm pseudocode. I asked:

"I need to write algorithm pseudocode. What's the best package right now — algorithm2e, algorithmicx, or something else?"

Axiom replied:

"Both are actively maintained. algorithm2e is self-contained and simpler to configure — good if you just need standard pseudocode without much customization. algorithmicx with algpseudocode gives you more control over formatting and is closer to the Algol style you see in CS papers. Since your document class is IEEEtran, I'd suggest algorithm2e — it plays well with IEEE margins without extra tuning. Want me to add it to your preamble?"

That's the kind of answer I actually needed. Not generic, not just a list — a recommendation with a reason, grounded in my actual document setup.

The error-based reverse lookup

The other pattern I use constantly: I get an error, and instead of searching for what's missing, I just ask.

Recent example. Compile error:

! Undefined control sequence.
l.83 \ce{H2O}

I pasted it into Axiom and asked what was happening. Response:

"\ce is a command from the mhchem package, which isn't loaded in your document. Add \usepackage[version=4]{mhchem} to your preamble — the version=4 ensures you're using the current API rather than the legacy interface. Here's the diff:"

+ \usepackage[version=4]{mhchem}

One click to apply. That took about ten seconds total.

Before TeX64, I would have searched "LaTeX undefined control sequence ce", found a thread that mentions mhchem, figured out which version option to use, and applied it manually. Maybe five minutes on a good day. Now it's ten seconds.

The diff-before-apply design

Something I appreciate about how Axiom is built: it never modifies your files silently. Every change goes through a diff display first, and you confirm before it's applied.

This matters more than it sounds. I've used other AI-in-editor integrations that just... change things. Then you don't know what changed, you're not sure if the change is correct, and your confidence in the document erodes.

Axiom shows you the change, explains it, and waits for your confirmation. If I disagree with the suggestion, I can just say no and ask for a different approach. The files stay untouched until I explicitly say yes.

How it handles "I don't know what I need"

Sometimes you don't even know what you're looking for. You just know the output looks wrong.

I tried: "My numbered lists inside theorem environments are using the wrong counter — the list items are numbered 1, 2, 3 but they inherit the theorem number weirdly. How do I fix this?"

Axiom figured out I was mixing enumerate with amsthm in a way that caused counter conflicts, suggested using enumitem with \setlist to reset counters inside theorem environments, and showed exactly where to add what.

It could have just recommended enumitem in the abstract. Instead it diagnosed the specific problem in my specific setup. That's the part that actually saves time.

Honest limitations

A few things worth knowing before you dive in:

macOS only. TeX64 is a native Mac app — Apple Silicon and Intel both work. No Windows version.

You still need a TeX distribution. TeX64 is an editor, not a compiler. You'll need MacTeX or TeX Live installed separately. TeX64 has a built-in environment checker that walks you through the installation if you don't have it — so it's not a hidden trap, but it's not plug-and-play either.

AI features have usage limits on the free tier. The free plan is enough to get a feel for how Axiom works. If you're writing regularly and asking Axiom questions daily, you'll probably want a paid plan. Heavy OCR and AI usage requires Basic or Pro.

Axiom is helpful but not infallible. Occasionally it suggests a package that technically works but isn't the optimal choice for a particular edge case. Especially with more obscure packages, the recommendations are good but worth double-checking.

The actual time savings

Before TeX64, I'd say package-related detours were costing me 30-60 minutes per writing session during my thesis. Each "which package for this?" question, each undefined command error, each "why isn't this rendering right?" moment triggered a search-and-experiment loop.

With Axiom, those questions take seconds to minutes. The answer comes with context and a diff. I say yes, it's done.

The cumulative effect over a 200-page thesis is significant.

---

If you're on macOS and writing LaTeX regularly, it's worth trying. Free tier, no account required to start. tex64.com