When Simple Beats Complex: Claude Projects vs

Ani Björkström, a Stockholm-based tech consultant, spent six minutes doing something that should make a lot of enterprise engineers uncomfortable. She uploaded five different document types into Claude Projects—PDFs, Excel spreadsheets, CSVs, Word documents, and a JPEG invoice—then asked questions without specifying which file to search. Every answer came back correct, with proper citations.

No vector database. No embeddings. No maintenance pipeline. No code.

The demonstration raises a question that's been hovering over enterprise AI for months: are we building complexity we no longer need?

The Test That Shouldn't Work This Well

Björkström's test wasn't sophisticated. She asked Claude to find net income figures from an annual report, extract termination clauses from a services agreement, sum transaction categories from a 48-row CSV, and read due dates from invoice images. Basic document interrogation—the kind of task that prompted organizations to build retrieval-augmented generation systems in the first place.

Claude answered every question correctly. "From page five, net income for 2025 is 612 millions," it reported for the PDF query. For the CSV calculation, it noted: "According to the transactions CSV file, the sum of training category expenses across 48 rows is $16,565." The system located the right document, extracted the right data, and cited its source without being told where to look.

This is supposed to require infrastructure. Traditional RAG systems chunk documents, generate embeddings, store them in vector databases, then retrieve relevant passages based on semantic similarity. It's elegant engineering. It's also maintenance-heavy, requiring ongoing tuning as document types change and query patterns evolve.

Björkström's point isn't that RAG is bad technology. It's that for many common use cases, it might be unnecessary technology.

What Changed

The shift comes down to context windows. Early large language models could handle a few thousand tokens—enough for a conversation, not enough for a company's document library. RAG emerged as the practical workaround: instead of feeding entire documents to the model, you'd retrieve the relevant chunks and feed only those.

Newer models handle significantly larger context windows. Claude, according to Anthropic, can process hundreds of thousands of tokens. That's multiple books' worth of text. For many organizations, that's their entire working document set.

When your context window exceeds your document library, retrieval becomes less critical. You can just load everything and let the model sort it out. That's what Claude Projects does: it accepts multiple files in various formats and searches across all of them simultaneously.

The technology sounds boring because it is boring. It's brute force—throw more compute at the problem until complexity becomes unnecessary. But boring solutions that work tend to outlast elegant solutions that require constant attention.

The Uncomfortable Questions

Björkström's demonstration surfaces tensions that enterprise technology teams know well. The question "Will you still use the traditional RAG and then do maintenance for RAG, or you feel like Claude Projects are a lot better alternative at this point?" isn't really about technology. It's about sunk costs and institutional momentum.

Organizations have built RAG pipelines. They've hired people to maintain them. They've integrated them into workflows. They've explained to leadership why this infrastructure matters. Now they're watching a consultant upload files to a web interface and get equivalent results.

This doesn't mean RAG disappears. For organizations with truly massive document collections—legal discovery systems processing millions of pages, research institutions with decades of publications—specialized retrieval still makes sense. Context windows have limits, and computational costs scale with input size.

But how many organizations actually operate at that scale? How many built RAG systems because they genuinely needed them, versus because RAG was the recommended approach when they started?

The technology industry has a pattern: we build complex solutions to real problems, then the underlying technology improves enough to make the complexity optional. Mainframes gave way to PCs not because mainframes were bad, but because PCs became good enough for most use cases. RAG might be following the same trajectory.

What Actually Matters

The interesting question isn't whether Claude Projects can replace RAG pipelines for simple document queries—Björkström's test suggests it can. The interesting question is what happens when simple document queries represent 80% of your use cases.

Enterprise technology decisions rarely optimize for simplicity. They optimize for capability, scalability, and control. Those are reasonable priorities when building infrastructure that needs to last. But they also create lock-in to complexity, even when simpler alternatives emerge.

Claude Projects isn't necessarily better than a well-tuned RAG system. It's just simpler. For organizations where "works well enough with zero maintenance" beats "works optimally with constant tuning," that simplicity matters more than theoretical superiority.

The video closes with Björkström's question to viewers, and it's worth asking seriously: if you're maintaining a RAG pipeline in 2026, is it because you need that specific architecture, or because you built it when it was the only option? The answer might determine whether you're doing necessary work or maintaining complexity out of habit.

Technology moves in one direction until it doesn't. We built distributed systems until cloud providers made them less necessary. We maintained on-premises infrastructure until SaaS proved reliable enough. We're building RAG pipelines while the context windows they were designed to work around quietly expand.

Björkström ran a simple test. The implications aren't simple at all.