The Frugal Scholar PART 2: The Learning Journey

The first thing I had to unlearn was the lie that software tools are neutral.

They're not. Every tool embeds a theory of knowledge. A belief about how research should work.

When I opened Zotero for the first time after canceling my subscriptions, I didn't just see a different interface. I saw a different epistemology.

The Question Behind the Tool

How does a researcher know? Not compute—know.

I'd been using Elicit and SciSpace for months without asking this question. They presented knowledge as something you extract. Type a query, get an answer. Like a vending machine for insights.

But research doesn't work that way. Understanding doesn't come from extraction—it comes from construction.

That weekend I spent migrating to open-source tools wasn't just technical. It was philosophical. I had to ask: How do I actually know what a paper says? What's the epistemological difference between an AI summary and my own notes?

The answer changed how I do research.

From Consumer to Constructor

Here's what I discovered: paid tools make you a consumer of knowledge. Free tools make you a constructor.

When SciSpace gives you a summary:

• You read it
• You trust it (or don't)
• You move on

The knowledge feels instant. But is it yours?

When you build your own system:

• You configure Zotero citation keys
• You design Obsidian templates
• You write Gemini prompts
• You create Pandoc workflows

Each decision forces a question: How do I want to think about this paper?

That question—that's where understanding begins.

The Three Moments of Clarity

Moment 1: The Template Revelation

I spent an hour designing my literature note template in Obsidian. Just the structure. Where does methodology go? How do I track key quotes? What metadata matters?

One hour felt wasteful. I could have processed three papers in that time.

But then I used the template. And used it again. And again.

By the tenth paper, something clicked: The template wasn't just storing my thinking—it was structuring it. Every paper now automatically connected to previous work. Themes emerged without effort. Patterns revealed themselves.

The template was an epistemological scaffold. I'd built a way of knowing.

SciSpace never taught me that. It just gave me summaries.

Moment 2: The Citation Key Epiphany

Better BibTeX asks you to choose a citation key format. Mine is [auth:lower]_[year].

So "Smith et al. 2024" becomes smith_2024.

Seems trivial, right?

But when I write in Markdown and type @smith_2024, something profound happens: I remember the paper. Not perfectly—just enough. Smith. 2024. The one about platform economics.

The citation key is a memory anchor. A tiny cognitive artifact that connects knowledge across time.

Elicit never asked me to think about this. It just inserted formatted citations. Perfect formatting, zero understanding.

Moment 3: The Prompt Engineering Awakening

Gemini's free tier gives you 25 requests per day. That's it.

So I had to get good at prompts. Fast.

First attempt: "Summarize this paper."

Output? Generic. Useless.

Second attempt: "Extract the research question, methodology (3 sentences max), key findings (bullets), and identify gaps this paper doesn't address."

Output? Exactly what I needed.

The difference wasn't Gemini—it was me. I learned to ask better questions.

Understanding precedes knowledge. I had to understand what I needed before I could get knowledge from the AI.

Elicit's interface never taught me this skill. It designed away the prompting layer. Convenience over capability.

The Knowledge Flywheel

Here's where it gets interesting.

With paid tools, knowledge is linear:

Paper → Tool → Summary → Done

With open-source systems, knowledge is circular:

Paper → Prompt → Summary → Template → Notes → Connections → Better prompts → Deeper understanding

Each iteration improves the system. And the system improves your thinking.

I've been running this flywheel for three months. My Gemini prompts are now surgical. My Obsidian vault is a knowledge graph with 200+ interconnected notes. My Zotero library exports to Markdown, feeds into Pandoc, generates perfectly formatted bibliographies in any style.

The system learns. Because I'm learning.

What I Learned About Learning

Three months in, I can articulate what changed:

1. I understand my tools

Not just how to use them—why they work. I know Zotero uses SQLite databases. I know Better BibTeX auto-exports to .bib files. I know Pandoc uses Citation Style Language (CSL) for formatting.

This understanding means when something breaks, I can fix it. When I need new functionality, I can build it.

2. I own my knowledge infrastructure

My notes are Markdown files. Readable in any text editor. Version-controlled in Git. Backed up to GitHub. Future-proof.

If Obsidian disappears tomorrow (it won't), my notes survive. If Gemini changes its API (it might), I adapt my scripts.

Ownership creates resilience.

3. I've developed meta-skills

This isn't just about research anymore. I've learned:

• Command line fluency (bash scripts)
• API integration (REST calls, authentication)
• Plain text workflows (Markdown, LaTeX)
• Knowledge management (Zettelkasten method)
• Version control (Git)

These skills compound. They transfer to every project I'll ever do.

SciSpace taught me nothing beyond "click this button." That knowledge died the moment I canceled my subscription.

The Cognitive Cost Nobody Mentions

But I need to be honest: This path has costs.

Learning curve: It took me a weekend to set up, another week to optimize. That's time I could have spent reading papers.

Cognitive overhead: Every workflow requires decisions. Template structure. Prompt engineering. File organization.

Initial productivity dip: First week, I was slower. No question.

The paid tools promise instant productivity. And they deliver—for a price. Not just money, but understanding.

You trade learning for convenience. Knowledge for speed.

I'm not saying that's wrong. Sometimes you need speed.

But I'm saying there's a cost we rarely acknowledge: When tools think for you, you stop thinking about how thinking works.

Why Understanding Matters More Than Tools

Here's what I've come to believe:

The best researchers aren't the ones with the best tools. They're the ones who understand how knowledge is constructed.

Tools change. Elicit today, something else tomorrow. The interface evolves. Features migrate from free to paid. Companies get acquired.

But epistemology—how you think about thinking—that's portable. Permanent.

I built my system on open-source foundations because I wanted to understand every layer. Not because I'm a masochist. Because understanding compounds.

Next year, when there's a better AI API, I'll migrate. 10 lines of code.

Next decade, when there's a better note-taking paradigm, I'll adapt. My notes are plain text—future-proof.

Understanding precedes knowledge. Knowledge precedes wisdom. And wisdom? That's what you get when you've built enough systems to see the patterns beneath them.

The Invitation to Think

I'm not here to convert you.

Maybe paid tools are right for you. Maybe you value speed over understanding. Maybe you don't care about owning your infrastructure.

That's valid.

But if you're curious—even slightly—about what it means to build instead of buy, I have a challenge:

Pick one tool in your workflow. Just one. Learn how it actually works.

Not how to use it. How it works.

If you use Notion: Learn how databases work. Try Obsidian for a week.

If you use Elicit: Learn what a language model API looks like. Try Gemini's free tier.

If you use Grammarly: Learn what a style checker does under the hood. Try LanguageTool.

Don't switch everything. Just learn one layer deeper.

See if it changes how you think.

What's Next

In PART 3, I'll show you what I built. The complete system. Every script, every template, every workflow.

Not because my system is perfect—it's not.

But because I want you to see what's possible when you stop consuming tools and start constructing knowledge infrastructure.

The freedom that comes isn't just financial. It's intellectual. Epistemological.

It's the freedom to know how you know.

Understanding precedes knowledge. Knowledge precedes wisdom. But building? Building precedes all of them.

🧠 Key Insight: Learning to build tools teaches you how knowledge works. That understanding compounds over time in ways no subscription can match.

📚 Resources I Used to Learn:

• Zotero documentation (zotero.org/support)
• Better BibTeX guides (retorque.re/zotero-better-bibtex)
• Obsidian community tutorials (forum.obsidian.md)
• Gemini API documentation (ai.google.dev/docs)

⏭️ Coming in PART 3: The complete system. Everything I built. How it works. Why it matters. And how you can build your own version in one weekend.