DEV Community: Anshul Prakash

PrePaste -- building it again, but better ❤️

Anshul Prakash — Mon, 12 Oct 2026 04:55:00 +0000

It all started with a pretty simple thought.

We copy and paste things hundreds of times every day. Sometimes it's just normal text, sometimes it's an API key, password, personal information, or something we really shouldn't be sharing.

And most of the time, we don't even realize it.

This is actually becoming a pretty big concern for companies too.

With everyone using third-party AI tools these days, employees can unknowingly end up sharing their company's internal data, client information, PII, API keys, or other sensitive secrets with external services.

Not because they mean to, but simply because it's so easy to copy something and paste it into an AI chatbot without thinking twice.

And that's exactly the problem I wanted PrePaste to solve.

A small, privacy-first desktop app that helps catch sensitive information before it accidentally leaves your hands.

How it all started

I originally built PrePaste during an OpenAI hackathon.

It was one of those ideas I really wanted to turn into something real, and the hackathon gave me the perfect excuse to do it.

The first version was built pretty quickly, with a fair bit of vibe coding involved hehe.

It worked, and I was genuinely happy with it.

But there's a difference between something that works for a hackathon and something people can actually trust and use every day, especially when privacy is involved.

So I decided to rebuild it.

Same idea, but this time, everything from scratch.

The part I didn't expect ❤️

After sharing PrePaste, something really sweet happened.

People actually started reaching out.

I got messages from developers in Germany, Korea, the USA, and quite a few others through Devpost, Discord, and LinkedIn.

Some wanted to try it, some had suggestions, some wanted to contribute, and some simply asked me to keep building it.

And honestly, that meant a lot.

It's one thing to build something because you think it's useful, but seeing people from completely different parts of the world interested in your little project is a completely different feeling.

A lot of my motivation to continue came from these people.

So thank you. Really.

So here we are, building PrePaste again!

This time, I want it to feel like a proper little product.

Something simple, polished, and genuinely nice to use.

I'm rebuilding it with a much cleaner foundation, a far more premium experience, and a little personality of its own, just like all my other projects.

I want PrePaste to fit naturally into your everyday workflow, without making privacy feel like another complicated thing you have to worry about.

And yes, it's going to be completely free and open source.

No subscriptions, no unnecessary paywalls. Just a useful little tool anyone can use.

A little glimpse 👀

I've also been working on the website, and I'm pretty excited about how it's turning out.

Here's a little glimpse of what's coming hehe.

I'm hoping to have a stable release ready within the next week. Fingers crossed!

One last thing ❤️

To everyone who's supported PrePaste so far, take my heart. ❤️❤️

More soon, hehe.

Optimizing LLM Context for OpenAPI: A Deterministic Approach to Token Reduction

Anshul Prakash — Tue, 11 Aug 2026 05:09:11 +0000

How deterministic context batching reduced approximate token usage by ~81.7% while building an agentic API testing prototype

See It in Action

I also recorded a short demo showing the complete workflow, from loading the OpenAPI specification to generating and executing tests, and auto healing:

Watch the demo on YouTube

I originally built this as part of my GSoC 2026 proposal for foss42.

I wasn't selected for GSoC, but while working on the proposal I had already built a working prototype of the system I wanted to contribute: an agentic API testing workflow that could read an OpenAPI specification, generate tests, execute them, and reason about failures.

And while building it, I ran into a problem that had little to do with HTTP itself.

The OpenAPI specification was becoming too large to send to an LLM efficiently.

That led me to build OpenAPI Context Batching -- a deterministic approach for giving an LLM only the relevant part of an OpenAPI specification instead of repeatedly sending the entire API.

In my prototype experiment, this reduced approximate token usage from ~50,000 tokens to ~9,200 tokens across the same five-interaction workflow; an 81.7% reduction🤯.

The Problem: OpenAPI Specs are Massive

The original goal of my project was to let an AI agent read an OpenAPI specification, generate test plans, and analyze API failures. But I quickly ran into a huge problem.

Real OpenAPI specifications are gigantic. They contain hundreds of endpoints, nested schemas, and complex validation rules. If you dump that entire JSON file into an LLM prompt, you run into two major problems:

It burns through thousands of tokens per single session.
The model gets completely overwhelmed and starts hallucinating fake endpoints.

If I just want the AI agent to test a /categories endpoint, it absolutely does not need to see the schemas for /payments or /cart or the endpoints not related to it. I realized I needed a way to give the model a smarter context instead of just a bigger one.

The Golden Rule: AI Plans, Dart Executes

Before I could optimize the tokens, I had to lock down the core architecture. I established one strict rule for the whole system: the AI figures out what to test, and Dart does the actual testing.

Letting an LLM directly execute HTTP calls is a terrible idea because it can easily invent fake responses. To prevent this, the model is constrained to generate a structured JSON test plan.

I built a standalone, headless Dart execution class called ApiTestRunner. This runner ingests the JSON test plan and performs the real HTTP requests using the networking layer of API Dash. The AI never touches the network directly.

The Solution: Deterministic Context Batching

So, how do we actually shrink a massive OpenAPI spec? We do not ask another AI to summarize it. We use deterministic code because OpenAPI is highly structured.

I wrote a custom Dart algorithm called OpenAPI Context Batching. Instead of sending the full specification, the script parses it and breaks it apart deterministically. Here is exactly how it works under the hood:

Domain Splitting: The script reads the raw OpenAPI JSON and splits the endpoints by their root domain, such as /auth or /categories.
Recursive Reference Resolution: OpenAPI heavily uses $ref to reuse shared schemas. If you only extract the endpoint path, the AI will not know what the data payload actually looks like. I built a recursive resolver that digs through the endpoint and finds every $ref.
Deep Schema Extraction: The resolver pulls in only the specific, deeply nested schemas required for that exact endpoint. This completely avoids sending the bloated components/schemas object.
Focused Context Map: The output is a clean Map<String, String> where each entry is the fully resolved, batched schema for just one domain.

When the agent needs to reason about a request, it only receives this highly focused batched schema. Because the algorithm is deterministic, the exact same OpenAPI specification always produces the exact same endpoint partitions every time.

The Guardrailed Retry Loop

To make the system even smarter, I built a conversational agentic mode with a self healing loop.

If the Dart execution engine runs a test and gets a failing non 2xx status code, it intercepts the error. It then injects the exact status code and response body back into the LLM prompt, asking the agent to fix the parameters automatically.

To make sure this does not result in an AI driven infinite loop that drains credits, I hardcoded a strict limit of three maximum retries.

The Results: 81.7% Token Reduction

I benchmarked this approach on a custom shop.json OpenAPI specification during my prototype development. The result was significant: approximately 81.7% fewer input tokens for the tested workflow.

Approach	Approximate Token Usage
Entire OpenAPI specification	~50,000 tokens
Context Batching	~9,200 tokens

By only sending the dependency aware context, I achieved an 81.7% reduction in token usage for a five step conversation workflow. Not only did it save a massive amount of tokens, but the focused context meant the AI responded faster and stopped hallucinating.

Approach	Visualization	Approx tokens
Entire OpenAPI passed at once		~50,000
OpenAPI Context Batching		~9,200

The Biggest Takeaway

The coolest thing I learned from this project is that we should not use LLMs for everything.

Parsing files, finding dependencies, and executing HTTP requests are tasks best handled by deterministic software. Generating test plans and reasoning about edge cases are where the LLM actually shines.

Building this engine independently of the Flutter UI also allowed me to expose it as an MCP server, meaning external tools like Claude Desktop can trigger real test runs. It was an incredible learning experience, and I am super excited to keep exploring how we can build smarter, more efficient developer tools!