DEV Community: Kanishaka Pranjal

Zero Users, One Job Offer: The Honest Post-Mortem of My AI Side Project

Kanishaka Pranjal — Mon, 30 Mar 2026 13:49:16 +0000

This is the story of how I spent seven months building an AI storytelling app, completely failed to market it, gave up on it in frustration, and still consider it the most successful failure of my career.

The Weekend Grind (January to July 2025)

At the start of 2025, I was in my 8th semester of B.Tech, juggling a flexible remote internship during the week. On paper, I was building my resume. In reality, the atmosphere was bleak. I was taking on freelance gigs just to stay afloat, and the looming dread of graduation without a full-time role lined up was a heavy physical weight.

I knew that if I didn't land a job soon, the frustration was going to spiral. So, FableWeaver.ai became my weekend obsession. Every Saturday and Sunday for seven months, I locked myself in to build.

The Mental Anchor & The Inspiration

Coding a massive full-stack Next.js/TypeScript application on top of a weekday internship and 4 to 5 hours of daily interview prep is a fast track to burnout. To survive, I built strict boundaries.

First, I built a physical anchor. Every morning, I hit the gym. Over 14 months, that daily discipline helped me drop from 83kg to a lean 64kg. It became my mental fortress, keeping the anxiety at bay and building the raw discipline I needed to code through the weekends.

Second, I refused to give up my hobbies. No matter how deep I was in the codebase, I carved out at least an hour every day to unplug and read web novels like Omniscient Reader's Viewpoint and Mother of Learning. But those stories weren't just an escape; they were the blueprint.

I was building FableWeaver for the community that raised me. I genuinely love these stories, and I have massive respect for the communities of readers and writers surrounding them. I wanted to give them a platform where AI characters could actually remember massive amounts of lore and interact autonomously.

The Technical Trenches

Building FableWeaver forced me to solve problems that no basic tutorial covers. The hardest hurdle was what I call the "Goldfish Effect."

The deeper a story went, the more the AI lost the plot arc. Imagine reading a 50-chapter fantasy book. In chapter 2, the author reveals a dark secret about the villain. But by chapter 15, the AI generating the story has completely forgotten the villain's motives and suddenly makes him a friendly barista serving the hero coffee. The context window just buckles under the weight of the lore.

Fixing that (building complex context management systems to keep the AI anchored to the truth) took months of trial and error. It was brutal, but it forced me to actually engineer, not just write API wrappers.

The Marketing Wall & The Post-Mortem

By July, the product was "done." It featured multiple AI agents interacting via Supabase Realtime and layered context injection. It was technically sophisticated, but invisible.

My marketing was a disaster. The bitter irony of FableWeaver is that the exact community I built it for—the readers and writers I loved—completely rejected it. I spent weeks lurking in Discord servers, desperately dropping links and pitching the app. Instead of welcoming the tool, I got swiftly hit with the ban hammer by mods for self-promotion.

If I had to do it over, I would not have spent seven months building in absolute silence. I would have built in public from day one, shared the technical struggles of managing AI context on Twitter, and asked writers for feedback before I ever wrote a line of code. Dropping a finished link into a chatroom is not community building; it is trespassing.

I lacked the resources and the audience to push it further. Exhausted, feeling the sting of rejection from my own community, and sitting at zero users, I looked at the finished product and did something rare in the "hustle" world: I gave up.

The 30-Minute Plot Twist

My primary reason for building FableWeaver wasn't to become a startup founder; it was to get a real job.

In mid-August, shortly after graduating, I hit a breaking point with standard job applications. Out of sheer frustration, I built a custom AI Agent web app in a single day to completely automate my cold email outreach (a wild story for another time). That agent landed me an interview for an AI Engineer role at WeAssist.io.

I wasn't interviewing with another engineer; I was sitting down with the Founder and the Product Manager. They needed someone who could bring deep AI knowledge to the table to actually build out their vision.

I didn't wait for them to ask me abstract LeetCode questions. I intentionally hijacked the conversation. I wanted to show them what I could build and exactly how I utilized AI to do it.

I pulled up the FableWeaver dashboard and took over the demo. I didn't even look for an "aha" moment from them; I was entirely laser-focused on showing the live product. I walked them through the autonomous AI group chats and explained how I solved the chapter context-loss problem under the hood. They saw the thousands of hours of weekend effort I had poured into the platform.

They were so impressed, they hired me in under 30 minutes.

The Real ROI

Today, as an AI Engineer, I can confidently say that FableWeaver.ai served its true purpose.

It might have zero users, but the skills transferred exactly. Handling complex agents, knowing exactly when to use a tool call, managing context tokens, and optimizing API costs for web apps are second nature to me now. Why? Because I already bled over those exact issues on my own time.

FableWeaver will likely never have a paying user. But a project with zero users is not a failure if it gets you exactly where you need to go. I didn't build a startup. I built a 2,000-hour technical interview that nobody could ignore.

I didn't get the users, but I got the job. And honestly, that was the point all along.

Stop Building To-Do Lists: How My Passion Project for Web Novels Taught Me AI Engineering

Kanishaka Pranjal — Mon, 16 Mar 2026 16:13:43 +0000

In 2026, everyone is building "Chat with your PDF" apps and AI Resume Screeners. These are the new to-do lists. Tutorial projects that prove you can call an API but not much else.

I was stuck in that loop too. Then I started building for an obsession I've had since I was a kid: stories.

How I Got Here

I was 13 when I wrote my first lines of QBasic. But my obsession wasn't code. It was worlds. Cartoons first, then anime and manhwa (Solo Leveling had me tracking power systems across 200+ chapters like a database), and eventually web novels. By the time I hit college at IIIT Sri City, I was reading Omniscient Reader's Viewpoint and Mother of Learning. Stories with thousands of chapters, hundreds of characters, and lore systems deep enough to crash a context window.

I didn't just want to read these stories. Since childhood, I'd wonder what it would be like to actually talk to these characters. And by 2020, I had entire worlds spinning in my head that I wanted to write down, but my writing couldn't keep up with my imagination.

So I built the tool I wished existed.

FableWeaver.ai

FableWeaver.ai is an AI-powered platform for writing interactive web novels. Not a wrapper around a chat API, but an actual system where characters remember their lore across hundreds of chapters and can talk to each other autonomously.

Building it forced me into two engineering problems that no tutorial covers.

Problem 1: LLMs Forget Everything

I call this the Goldfish Effect. Most student AI projects work fine for short documents. But feed an LLM a 200-chapter novel and it forgets the protagonist's hidden motive from Chapter 2 by the time you hit Chapter 50. The context window just isn't big enough to hold an entire world.

My first instinct was basic RAG: retrieve relevant chunks and stuff them into the prompt. That works for documentation search. It does not work for narrative, where foreshadowing from 30 chapters ago matters as much as what happened last paragraph.

So I built a layered summary system instead. Three tiers of context, each serving a different purpose:

World lore: the rules of the universe, character backstories, magic systems. Static. Never changes unless the author edits it.
Arc summaries: a compressed version of the current ~10-chapter plot arc. Updated every few chapters.
Chapter recap: a detailed summary of the immediately preceding chapter. Regenerated every time.

When the AI writes a new chapter, it gets all three layers injected into the prompt. It knows the world, it knows the current plot arc, and it knows what just happened.

// Fetch the three context layers for prompt injection
const { data: layers } = await supabase
  .from('context_layers')
  .select('type, content')
  .in('type', ['world_lore', 'arc_summary', 'chapter_recap'])
  .order('type');

const worldLore = layers?.find(l => l.type === 'world_lore')?.content ?? '';
const arcSummary = layers?.find(l => l.type === 'arc_summary')?.content ?? '';
const lastChapter = layers?.find(l => l.type === 'chapter_recap')?.content ?? '';

const prompt = `World: ${worldLore}
Current Arc: ${arcSummary}
Previous Chapter: ${lastChapter}

Continue the story. Write Chapter ${currentChapter}.`;

Problem 2: Characters That Talk to Each Other

While most people build 1-on-1 chatbots, I wanted a full cast that could argue with each other. And with the reader.

Each character is its own AI agent with a system prompt that locks down their voice, their secrets, and their constraints. A brooding anti-hero gets "Never agree easily. Question motives. Use short sentences." A court scholar gets "Speak formally. Reference historical precedents. Never use contractions."

The tricky part was orchestration. I wired it up with Supabase Realtime so the agents run in a shared channel:

A user drops a message into the group chat.
The hero agent responds.
The rival agent "hears" the response, runs it through a personality-weighted prompt, and decides whether to interject or stay quiet.
A turn-taking manager prevents infinite agent loops. This was a real problem in early builds. Two agents would just argue forever.

The result is a conversation that feels alive. You're not chatting with a bot; you're in a room with characters who have their own agendas.

What Broke

Two things nearly killed the project.

Summary decay. I initially had the AI summarize the previous summary every few chapters. Classic shortcut. By chapter 20, it was like a game of telephone. The plot had hallucinated into something unrecognizable. A character's betrayal got softened into a "disagreement," key plot points vanished entirely. I fixed this by anchoring every 5th summary back to the original world lore, so the summaries could never drift too far from ground truth.

Character bleed. After about 10 messages in the group chat, every character started sounding the same. Polite, helpful, agreeable. Turns out LLMs have a strong gravitational pull toward a "default helpful assistant" voice. I had to fight this with negative prompting: explicitly telling each agent what they would never say or do. That made the difference between a cast of identical chatbots and characters with actual friction.

The Takeaway

My first shipped project was GoodWill, a messy MERN stack app connecting NGOs with donors. Three organizations actually used it. The tech was barely held together, but it taught me something no tutorial ever did: a shipped, imperfect product is worth more than a perfect one that never leaves localhost.

FableWeaver was the same lesson at a harder difficulty. It taught me context window management, multi-agent orchestration, and real-time state management. Not because I was following a curriculum, but because I needed to solve these problems to make my thing work.

In 2026, the bar has moved. Recruiters don't care that you can call an API. They want to see that you can manage state, handle latency, and keep an AI system coherent over time. You learn that by building something you actually care about, something where cutting corners means your own experience gets worse.

Find the gap in your hobbies. Build the bridge.

This post was originally published on kanishakapranjal.com.

The True Mother of Learning

Kanishaka Pranjal — Wed, 04 Mar 2026 08:04:32 +0000

If you had to answer the question, "What is the mother of learning?" what would you say?

It is a slightly philosophical question, and the answer varies. Some might say patience. Others might say curiosity. For me, the absolute mother of learning is applying.

💡 Tip:
Quick aside for the fantasy fans: Mother of Learning is a legendary web novel where the protagonist masters magic by reliving a one-month time loop hundreds of times. The principle is simple: progressive repetition, applied relentlessly, until mastery.

Universally, the core of human skill acquisition is progressive repetition. We try something, we fail, we adjust our approach, and we try again. We loop through the problem until it clicks.

The most fascinating part about this concept? That is exactly how Artificial Intelligence learns, too.

The Human and Machine Parallel

When we look at Machine Learning, models go through "epochs": massive cycles of progressive repetition. They ingest data, make a prediction, calculate the error, adjust their parameters, and repeat.

Whether human or machine, mastering a new skill requires looping through the data until the patterns make sense.

My AI Journey: From Curiosity to Production

My own journey into the world of AI mirrored this exact process. Back in 2022, I didn't start with complex architectures. I started simply as a curious user messing around in the OpenAI Playground.

I was hooked. I spent my weekends reading articles, consuming documentation, and testing prompts. Soon, I was in the Playground at least five times a week, pushing the limits of what the models could generate.

But I realized early on—whether I was 13 writing my first lines of QBasic or later building full-stack applications—a shipped, imperfect product teaches you more than a polished tutorial ever could.

I used progressive repetition to go from testing basic prompts to engineering actual products:

Voice-based AI: Integrating OpenAI's Realtime API and WebRTC to build interview simulators.
Generative Storytelling: Leveraging the Gemini API for platforms like FableWeaver.ai.

Architecting the Future

Fast forward to today, and that initial curiosity has evolved into my daily reality as an AI Engineer.

I went from testing prompts to building entire platforms from scratch. Today, my work revolves around architecting AI-powered full-stack systems with Next.js, TypeScript, and AWS. I build platforms where AI handles the operational grunt work so humans can focus on the work that requires actual judgment.

The Takeaway

If you want to understand Artificial Intelligence, you cannot just read about it. You have to get your hands dirty.

Find a tool, hit the API rate limit, figure out why your WebSocket dropped, and build it better.

This post was originally published on kanishakapranjal.com.

The mother of learning is applying.

Let's discuss: What is one project you "applied" yourself to that taught you more than any book ever did? Drop it in the comments!