DEV Community: Shweta Mishra

Built a proxy, so my AI coding sessions stop forgetting everything after 20 turns

Shweta Mishra — Thu, 09 Jul 2026 20:04:26 +0000

If you've used Claude or GPT for a long coding session, you know the drill. Context fills up, it summarizes, and a few turns later it's suggesting a library you already rejected, or forgetting why you picked postgres over MySQL in the first place.

I built TokenMizer to fix that. It's a local proxy that sits between your app and whatever LLM you're using. Instead of dumping raw conversation history back at the model, it builds a small graph of what actually happened in the session, tasks, decisions with the reasoning behind them, files touched, errors hit.

Using it is a one line change:

from openai import OpenAI

client = OpenAI(api_key="your-key", base_url="http://localhost:8000/v1")

response = client.chat.completions.create(
    model="claude-sonnet-4-6",
    messages=[{"role": "user", "content": "Let's build an auth service"}],
    extra_body={"session_id": "my-project"},
)

When context hits around 85%, it auto-checkpoints. I ran a 40-turn session that resumed the next day in 233 tokens instead of re-explaining the whole project from scratch. Decisions carry state too, active, superseded, invalidated, archived, so "why did we switch from React to Next.js" is still answerable weeks later instead of buried in a chat log nobody's scrolling back through.

There's also a file intelligence layer. Drop in a CSV, PDF, or Excel file, and it gives the model a schema and sample instead of burning your entire token budget on raw rows, 99%+ savings on large files.

Works with Claude, GPT, Gemini, Grok, DeepSeek, and Ollama out of the box. There's a Claude Code plugin and an MCP server if you want it wired straight into your editor.

pip install "tokenmizer[anthropic,cache]"
tokenmizer serve

Repo's here: https://github.com/Shweta-Mishra-ai/tokenmizer

Still actively building this, would love to know if this is a problem you've hit too, and how you're dealing with it right now.

Forget the $5,000 Bootcamp: The Definitive, Open-Source AI & Data Engineering Syllabus for 2026

Shweta Mishra — Thu, 09 Jul 2026 19:38:22 +0000

The tech landscape is moving too fast for traditional academia. By 2026, the traditional divide between "technical execution" and "non-technical strategy" has completely collapsed. AI models have commoditized basic code syntax, simple data entry, and cookie-cutter UI generation.
If your core career value relies entirely on doing predictable engineering work, you are competing against automated agents that operate near-zero marginal cost.
The premium roles belong exclusively to the Orchestrators - the systems architects who manage fleets of micro-agents, secure data pipelines, and design resilient infrastructure.
You do not need to drop thousands of dollars on a predatory bootcamp to learn these skills. The entire, production-grade curriculum is being open-sourced daily by world-class engineers. If you have the discipline to sit down and build, here is your definitive, zero-dollar syllabus to mastering the modern AI and Data ecosystem.

Data Architecture & Analytics: Building the Single Source of Truth
Before you can orchestrate intelligent systems, you must master the core pipelines that feed them. Without pristine data handling, your advanced LLM applications are nothing more than automated hallucination engines.
W3Schools: The absolute baseline repository for core syntax. Before handling complex distributed databases, you must master the fundamental rules of execution. Use their structured, interactive frameworks as your daily baseline documentation for Python, SQL, and web fundamentals.
Data with Baraa: Led by 17+ years of elite enterprise experience (including ex-Mercedes Benz engineering), this channel delivers unparalleled breakdowns of enterprise data platform design. His SQL and Python playlists are structured better than top-tier university lectures.
Zach Wilson: The industry authority on dimensional data modeling. If you want to understand how to design scalable, production-grade data lakes and survive the brutal realities of handling massive distributed datasets, start here.
Luke Barousse: Technical skills mean nothing without proof. This channel provides concrete, project-based tutorials that teach you exactly how to build a data architecture portfolio that converts cold applications into technical interviews.
Alex The Analyst: The premier resource for a complete, end-to-end analytics bootcamp. He systematically guides you from foundational Excel data-cleaning mechanics to advanced Business Intelligence (BI) implementations.
sqlbelle: The absolute gold standard for database extraction logic. If you need to clear the hurdle of advanced SQL query patterns, relational algebra, and window functions, her crystal-clear pedagogy is essential.
AI Engineering & LLM Architecture: Beyond the API Wrapper
An AI Engineer isn't someone who writes long prompts inside a web UI. True AI Engineering requires understanding how context windows scale, how data maps into vector spaces, and how to control non-deterministic systems.
Andrej Karpathy: The absolute gold standard of AI education on the internet. His "Neural Networks: Zero to Hero" series bypasses superficial libraries and forces you to build backpropagation and transformers from the mathematical ground up. This is how you stop being a wrapper developer.
Matthew Berman: The ultimate resource for tracking and deploying open-source foundational models locally. If you need to figure out which small language model (SLM) fits your strict data privacy requirements and how to serve it efficiently, watch his daily breakdowns.
AI Jason: Production AI relies heavily on agentic workflows and complex RAG (Retrieval-Augmented Generation) pipelines. His channel provides tactical, step-by-step blueprints for building self-correcting agent systems that communicate over structured APIs.
Krish Naik: A powerhouse repository of comprehensive technical playlists. He covers the entire spectrum from core mathematical Statistics and Machine Learning algorithms to deep learning framework deployments.
MLOps & System Infrastructure: Engineering for 99.9% Uptime
An AI model running locally inside a Jupyter Notebook is a toy. To build an enterprise-grade asset, you must understand containerization, automated testing, continuous integration, and secure orchestration.
TechWorld with Nana: If your application isn't containerized, it isn't production-ready. Her DevOps and platform engineering crash courses are mandatory reading for understanding how Docker, Kubernetes, and CI/CD pipelines keep applications alive under heavy load.
ByteByteGo (Alex Xu): The absolute highest-quality visual breakdowns of large-scale distributed systems on the internet. If you want to understand load balancing, message queues, and caching strategies for global scale, look no further.
DataTalksClub: Famous for their completely free, deeply rigorous Data Engineering and MLOps "Zoomcamps." These intensive, project-driven community curriculums match or exceed the technical depth of specialized enterprise training programs.
MLOps Community: A specialized hub for senior engineering discussions. It focuses deeply on the realistic infrastructure, compliance barriers, logging mechanisms, and telemetry required to maintain machine-learning models in enterprise ecosystems.
AI Product & Full-Stack Integration: Designing the Interface
An intelligent system needs an interface to deliver business value. You must know how to decouple your complex AI backends from highly performant, secure front-end applications.
JavaScript Mastery (Adrian Hajdin): The undisputed benchmark for full-stack integration. His comprehensive masterclasses teach you exactly how to tie raw Python/AI backend endpoints into stunning, secure, and lightning-fast web applications using Next.js.
Fireship: High-density, zero-fluff overviews of emerging frameworks, tech stacks, and tools. This is your radar for keeping your architectural knowledge bleeding-edge in an ecosystem that shifts every 24 hours.
freeCodeCamp.org: The ultimate open-source warehouse for long-form coding bootcamps. Whether you need a 10-hour deep dive into data structures or a comprehensive introduction to relational databases, their library is unmatched.
Web Dev Simplified: Specializes in dismantling convoluted web development patterns, API integrations, and async programming paradigms into clean, highly readable, and easily digestible engineering logic.

The Orchestrator's Ultimatum
The economic reality of the current tech ecosystem is simple: The barrier to entry has completely evaporated, but the bar for production reliability has never been higher.
You no longer have an excuse. The tools are open source, the documentation is free, and the best minds in software engineering are publishing their playbooks weekly on YouTube. The only variable remaining is your personal discipline to sit down, write the configurations, break your deployments, and build real systems.
Stop watching tutorials passively. Pick an ecosystem role, clone a repository, and start orchestrating.
What is the single open-source resource or creator that completely transformed your technical trajectory? Let's map out the best community recommendations in the responses below.

I Was Burning Money on AI Tokens Without Knowing It — Here's What Fixed It

Shweta Mishra — Thu, 02 Jul 2026 13:47:35 +0000

A few months ago, I was running long AI coding sessions that would just... stop working well after a couple of hours. Not crash. Just get worse. Slower, more expensive, and weirdly forgetful — like the model had too much on its mind.
Turns out, it did.
I dug into what was actually happening under the hood, and the answer surprised me: it wasn't the AI model that was the problem. It was everything I was feeding it.
The junk drawer problem
Think about how most AI tools handle memory. Every message, every file you opened, every decision you made gets shoved into context. Nothing gets cleaned up. Nothing gets organized. It's like a junk drawer that keeps growing — except every time the AI needs to find something in that drawer, you're paying for it. In tokens. In money. In slower responses.
And here's the part that really got me: this mess doesn't just cost more. It actually makes the AI's answers worse. Buried under redundant, outdated information, the model starts missing what actually matters.
What I found when I actually measured it
I decided to stop guessing and start measuring. I built a system to track exactly what was useful in a long AI session versus what was just noise — repeated file reads, decisions that got reversed three messages later, errors that were already fixed but kept getting mentioned again.
The results were honestly kind of embarrassing. A huge chunk of what gets fed to AI models in long sessions is just... repetition. Same information, described five different ways, sitting in context, costing money every single time the model has to process it.
So I built something to fix it. Three ideas made the biggest difference:
Organize, don't accumulate. Instead of one long messy transcript, I split everything into categories — goals, decisions, files touched, errors hit. Suddenly the system could pull exactly what it needed instead of re-reading everything.
Track the current decision, not every decision ever made. If someone says "let's switch to Postgres" after saying "let's use SQLite," most systems keep both floating around in context. Mine tracks the chain and keeps only what's actually true right now.
Save a snapshot, don't replay the whole story. For long sessions, instead of reconstructing everything from scratch, the system checkpoints where things stand and picks up from there.
The numbers that mattered to me
After building this out, the system was holding onto 76% of important tasks and 85% of key decisions correctly — while using a fraction of the tokens a "keep everything" approach would need. Every one of the 67 tests I wrote to check accuracy kept passing through each round of changes, which mattered to me more than any single benchmark number. A cheaper system that gives wrong answers isn't actually cheaper. It's just wrong and cheap.
Why this matters beyond my one project
Here's the thing I keep coming back to: efficiency and accuracy aren't actually enemies. Most of what gets cut when you clean up context is genuinely useless information. You're not sacrificing quality to save money — you're removing noise that was quietly making things worse anyway.
If you're building anything with AI models — a chatbot, a coding assistant, an agent that runs for a while — the biggest cost lever probably isn't the model you're using. It's how much irrelevant history you're dragging along with every single request.

Most systems have 30-50% of token usage sitting around as pure waste. No model upgrade required to fix that. Just better housekeeping.

I write about building practical AI systems — memory, context, and the unglamorous engineering that makes AI tools actually work in production. If this was useful, I'd love to hear what context problems you're running into in your own projects.