DEV Community: Kandeepa Sundaram

The Augmentation Mindset: How I Built an App to Amplify, Not Replace, My Book Fair System

Kandeepa Sundaram — Wed, 29 Jul 2026 07:30:00 +0000

I have a system.

For 11 years, I've attended every single edition of my town's book fair. Not one miss. Not even during the COVID year when they moved it outdoors with masks and sanitizer stations. I was there.

This isn't casual browsing. This is clockwork. This is tradition.

And this year, I finally built an app to go with it.

But here's the thing—the app didn't replace my system. It didn't replace my judgment, my taste, or the hard-earned intuition that comes from years of reading and buying books. What it did was amplify everything I already knew.

Because when you combine human wisdom with algorithmic efficiency, you don't just buy better books. You become unstoppable.

The Ritual (Phase 1: Reconnaissance)

The fair runs for 10 days. I never buy everything in one visit. That's amateur hour.

Visits 1 & 2 – I go in with zero intent to purchase. Well, almost zero. I allow myself one or two books—the ones I've been waiting for all year. The new releases. The out-of-print gems. The ones that would break my heart if someone else grabbed them.

For everything else? I log.

My weapon of choice for the first 10 years: a single A4 sheet of paper, folded into four long sides. Old school. Reliable. No battery required. No API dependency. No downtime.

I walk stall to stall, row by row. My left hand holds the folded paper. My right hand holds a pen. I jot down:

Stall number (because I will forget where I saw it)
Book title and author
Price (the one they quote, not the MRP)

By the end of Visit 2, that A4 sheet is dense. Tiny handwriting. Arrows crossing out prices I misheard. Asterisks next to "must reconsider." Sometimes I run out of space and start writing vertically in the margins.

I usually have 75–100 books on that list.

That's not a shopping list. That's a dataset. Built by hand. Curated by instinct. Refined over 11 years of trial and error.

(And yes, I still have all those folded sheets—neatly archived in a file. Eleven years of book fair history, preserved in ink. Sometimes I flip through them just to see how my taste has evolved.)

The Ritual (Phase 2: Consolidation & Scrutiny)

Visit 3 is where the magic—and the headache—happens.

I take my folded A4 sheet home. Spread it out on my desk. Open my laptop. And I transcribe everything into a massive spreadsheet.

Yes, I manually type out 75–100 book titles, stall numbers, and prices. Yes, it takes a couple of hours. Yes, my neck hurts afterward. But this is the consolidation phase, and it's sacred.

Now the real work begins—and this is where human judgment takes over:

Prioritization – I rank every book on a scale. 5 = "will regret forever if I don't buy." 1 = "interesting but I can live without it." This isn't random—it's shaped by years of knowing what I actually finish reading versus what gathers dust.
Review check – I cross-check Goodreads, YouTube book reviewers, and Reddit threads. But I don't blindly trust scores. I've learned that a 4.2 star book in one genre is different from a 4.2 star book in another. Context matters. I bring the context.
Price comparison – I check online stores for every single title. This alone takes time. And I know which platforms usually have the best deals for which genres.
Edition verification – Is the fair copy a newer edition? Better cover? Different translator? I've been burned before. I know which publishers produce quality editions and which ones cut corners. That's not in any database—that's in my memory.

By the end of this phase, I have a refined, sorted, hyper-analyzed list of about 40–50 books that made the cut.

The Ritual (Phase 3: The Budget War)

Here's where it gets brutal.

My total wishlist usually adds up to around ₹40,000–50,000. That's a significant amount, and I need to be disciplined.

So I start killing my darlings. And this is purely human intuition:

The book with a 4-star rating but I already own 3 other books by the same author and haven't finished two of them? Drop.
The one that's cheaper online but I want it now because I'm going on a trip next week? Keep.
The one I'd "probably read someday"? Drop. Drop. Drop. (I've learned that "someday" rarely comes.)

I trim the list down to 20–30 books, bringing the final spend to around ₹20,000. These are the chosen ones. The ones that survive the gauntlet.

Then I go back for Visit 4 (and sometimes Visit 5) with a mission: buy only those 20–30, stall by stall, checking each one off my list like a hunter.

By the end, I'm exhausted, ecstatic, and a few thousand rupees poorer. But my bookshelf is glorious.

The Problem That Finally Broke Me

This system works. It has worked for 11 years.

But this year, I hit a wall.

During Visit 3, while manually typing 80+ book titles into my spreadsheet, I realized: I have been doing this exact same data entry for over a decade.

I'm a developer. I build automation for a living. And I was manually transcribing scribbled notes from a folded piece of paper like it was 1995.

That's when I snapped.

I closed the spreadsheet. Opened VS Code. And spent the next few hours building what I should have built years ago.

The App: AI + My System, Not AI vs. My System

Here's the critical distinction: I didn't build the app to replace my judgment. I built it to handle the grunt work so my judgment could focus on what actually matters.

What the App Does (The Automation Layer)

1. Quick Log Mode (Replaces the A4 Sheet—But Keeps My Curation)

Open the app, tap "New Find," and log: stall number, book title (via camera OCR), price.
No more cramped handwriting. No more "wait, what stall was this again?"
But I still decide what gets logged. The app doesn't suggest books. It doesn't curate. That's my job.

2. Smart Consolidation Dashboard (Replaces the Spreadsheet—But Keeps My Prioritization)

The app aggregates all my logged books into a single, sortable, filterable list.
It shows fair price, online price (via API), price difference, and ratings.
But I still assign the priority score. The app doesn't tell me what to prioritize. It just gives me the data faster so I can spend more time thinking and less time typing.

3. The Budget Optimizer (The Knapsack Algorithm)

I set my budget. I assign each book a priority score.
The app runs a knapsack algorithm—a classic optimization problem—to suggest combinations that maximize total priority within budget.
Here's the key: it suggests, it doesn't decide. I still override it. I still swap books based on gut feel. The algorithm doesn't know that I've been wanting that obscure memoir for years. It doesn't know that I already own 5 books on the same topic as that "high priority" recommendation. I know that. The app doesn't.

4. Stall Mapping

The app builds a map of all my "must-buy" books by stall.
On Visit 4, I open the map and plan my route.
This is pure efficiency. It saves me physical exhaustion. But I still decide which books make the final cut.

5. Final Checklist

As I buy each book, I tap "Purchased."
The app tracks my remaining budget in real-time.
If I find a surprise gem (which always happens), I can swap it with a lower-priority book and recalculate instantly.
The app handles the arithmetic. I handle the strategy.

The AI Layer (Where It Actually Helped—But Didn't Take Over)

I used AI sparingly. Deliberately. In places where it augments, not replaces.

OCR for ISBN & Title Extraction

Instead of typing book titles while juggling a chai and a tote bag, I snap a photo.
Gemini extracts the title, author, and ISBN in seconds.
But it makes mistakes. Blurry photos, bad lighting, weird fonts. And here's where I come in—I verify every extraction. I correct the errors. The AI handles most of the work; I handle the part that requires human discernment.

Automated Review Summaries

Instead of opening Goodreads for every book, the app fetches the top reviews and generates a one-line summary using a lightweight LLM.
Example: "Widely considered the best business book on disruption—but some find it dense."
But I don't trust it blindly. I've read enough reviews to know when an LLM is paraphrasing fluff. I still dig deeper for the books I'm genuinely considering.

Price Trend Prediction

The app shows historical price data: "Currently trending lower than last month—good time to buy."
This is helpful. But it doesn't account for things like: "I'm going on a trip next week and I want to read this on the flight" or "I have a gift card expiring soon." Those are my inputs. The AI just provides the raw signal.

The First Real Test: AI + Me, Together

Visit 3 was my trial run.

I walked in with my phone instead of my folded A4 sheet. I logged over 70 books in a couple of hours. The app categorized them, compared prices, and pulled reviews—all in real-time.

That evening, I sat at my desk (no transcribing this time) and opened the dashboard. All my books sorted by priority, price difference, and stall number.

I set my budget. The optimizer ran in milliseconds and suggested a balanced list.

I cross-checked against my gut. It matched almost perfectly—except it had swapped out a few books I was lukewarm about for some cheaper ones I'd overlooked. That's the kind of insight I would never catch manually. The algorithm saw patterns in my own prioritization that I was blind to.

But I also overrode it. I kept a book that was over budget because I'd been waiting for that author's new release for years. The algorithm didn't know that. I did.

Visit 4 took much less time than usual. I bought my final shortlist, stayed within budget, and walked out with zero regret.

The Deeper Lesson: AI Doesn't Replace—It Amplifies

Here's what I walked away with:

My experience was the real asset. The app didn't teach me how to prioritize. It didn't teach me which books are worth reading. It didn't teach me the difference between a good translation and a great one. I already knew all that.

What the app did was compress the borining parts—data entry, arithmetic, cross-referencing, route planning—so I could spend more time on the parts that require human judgment: curation, intuition, strategy, and the joy of discovery.

The best AI tools aren't the ones that think for you. They're the ones that think with you.

A reader with deep experience + an AI that handles the grunt work = a combination that's greater than either alone.

The AI didn't replace me. It made me more me.

What This Means for Techies Everywhere

If you're a developer reading this, here's the takeaway:

Your expertise is irreplaceable. AI can't replicate years of context. It can't replicate your gut feel. It can't replicate the nuanced decisions you make based on things that aren't in any database.

But AI can handle the repetitive, error-prone, time-sucking parts of your workflow. The parts that drain your energy and leave you exhausted before you even get to the interesting work.

The goal isn't to build an AI that does everything. The goal is to build a system where AI handles the grunt work, and you handle the strategy.

That's the powerful combination. That's the future.

Final Thought (For Fellow System-Lovers)

If you have a ritual—whether it's book fairs, grocery shopping, or planning vacations—don't just do it. Study it. Map it. Find the friction points.

Then ask yourself: "What would I build if I had a few hours and a decent API key?"

But more importantly: "What part of this requires my unique expertise, and what part can I offload to automation?"

The answer to that second question is where the magic happens.

Because when you combine human intuition with algorithmic optimization, you don't just buy better books.

You become unstoppable.

P.S. — My folded A4 sheets from all 11 years are neatly archived in a file. Sometimes I flip through them—just to see how my taste has evolved, what I almost bought, what I'm glad I skipped. Never forget where you started. And never forget what you bring to the table—AI doesn't replace that. It just gives you more time to use it.

Who Am I?

Kandeepa Sundaram — Fri, 03 Jul 2026 00:00:00 +0000

The cognitive tax of Git identity management — and how I fixed it

I still ask myself this question before every commit: Who am I right now?

That hesitation. The finger pause. Not philosophy. Just ~~Gut~~ Git feeling.

I've pushed personal commits to client repos. I've also done the reverse — work identity on open-source PRs. Nothing broke immediately. But in regulated environments, that wrong name starts an audit conversation nobody wants to have.

After nearly two decades of this, I've realised the most expensive bugs aren't in the code. They're in the seams around it. Git identity is one of those seams. And almost nobody talks about it.

The Four Flavours of This Pain

Here's the thing: I don't work under a single identity anymore. Neither do you.

One hour I'm pushing to my company's GitHub org. Next, I'm debugging a freelance client's GitLab repo. Then I'm patching an open-source project I maintain. Each one expects a different email, a different SSH key, maybe a GPG signature if the org requires signed commits.

Git is brilliant at tracking changes. It's terrible at tracking intent. It doesn't know who I meant to be — it just uses whatever profile happened to be active last. That gap? That's where the friction lives.

The wrong name on a commit. You write an hour of code, push, and someone pings you: "Hey, this came from your personal account." Now you're amending, force-pushing, and explaining yourself to someone who doesn't care about Git — they just want the fix. The code was fine. The identity wasn't.

The endless shuffle. git config user.email "work@company.com". Later: git config user.email "me@gmail.com". Each switch takes ten seconds. Over a year, that's hours. And one forgotten switch undoes all of it.

Key chaos. Separate SSH keys per account. Signed-commit requirements per org. Pick the wrong one, and your ten-second commit turns into a debugging session or a rejected pipeline. You're not writing code anymore — you're playing key-ring roulette.

The cognitive tax. This is the one that hurts most. It's not the time. It's the interruption — that fraction of a second where your brain leaves the problem you were solving and asks: am I the right person right now? That fracture in flow state is more expensive than any of the others. Because you don't just lose the seconds. You lose the immersion.

The DIY Rabbit Hole

I did the math one week. By Wednesday, I'd already lost count.

Not because I'm disorganised. Because every repo, every client, every org has its own rules — and Git, for all its brilliance, has no mechanism to say "you're in the work directory, here's your work hat."

I tried to fix it the way any engineer would. Aliases. Shell scripts. A half-baked direnv setup that worked 80% of the time and failed catastrophically the other 20. Each time, I'd patch one hole, and a new context would open up — different SSH key, stricter GPG policy, a client who wanted commits signed with their specific subkey.

I even tried the obvious shortcut: gh auth switch. It's a toggle. You flip it, it changes your GitHub context, but it doesn't touch your global Git config. It doesn't remember that this directory needs a specific SSH agent. It doesn't manage GPG signatures. It's a solution for bouncing between GitHub accounts — but it doesn't solve the core cognitive problem: the decision-making. A manual light switch when I needed a motion sensor.

But the real WTF? It wasn't any of that. It was realising I'd just accepted this as normal. Like pausing before every push to mentally run a checklist was just... part of the job.

That's when I stopped blaming myself and started looking at the seam.

The Organizational Paper-Cut

And I'm not alone in this. What's a paper-cut for me is a process cost at scale.

Senior engineers burn time on other people's auth failures. New hires lose their first hour to Git setup instead of shipping code. In regulated environments, a mis-attributed commit isn't just embarrassing — it's an audit flag. The individual friction becomes organizational drag.

The code is almost never the problem. The identity attached to it is.

Enter Grit

So I built something that sits exactly at that seam.

Not another wrapper. Not a custom Git command you have to remember. A background daemon that watches where you're working and applies the right identity before you commit. Automatically.

I called it Grit.

The design was simple: make the decision once, then forget it exists.

Instead of switching configs manually, Grit remembers which identity belongs to which context. You tell it once — "this directory is work, this remote is my open-source account, this repo needs a signed commit" — and it handles the rest.

How It Actually Works

Detection rules. Define patterns once — directory paths, remote URLs, even repo names. Grit matches where you are and applies the right profile. No commands, no toggles.

~/work/bank-client/*     → Work Profile (SSH: work-key, GPG: on)
~/oss/*                  → Personal Profile (SSH: personal-key, GPG: off)
github.com/my-company/*  → Corporate Profile (signed commits required)

Pre-commit protection. This is the part I'm most proud of. A Git hook that verifies your identity before the commit is created, not after you've already pushed and someone points out the mistake. It's defense-in-depth — the daemon handles the happy path, the hook guards the edge cases.

Per-profile keys. Each identity carries its own SSH key and GPG signing config. No more debugging which agent loaded which key. No more rejected pipelines because you used the wrong signature.

Session memory. Grit restores the right identity when you return to a repo. Open a project you haven't touched in months — it picks up where you left off.

And it runs quietly in the background. Windows, Linux, macOS. Offline-first. No cloud, no telemetry, no account required.

The Hard Part

The hardest part wasn't the switching. That's one shell command. The challenge was building a decision engine that handles ambiguity gracefully.

What happens when a path matches two rules? What if there's no rule? What if the remote URL doesn't match anything I've defined?

I built a fallback chain: explicit .grit file in the repo → directory rules → remote patterns → explicit session override → global config. There's always a fallback, and you always know which one applied.

That's the architectural muscle I've spent two decades building — pointed at a paper-cut I lived with every single day.

Try It Today

It's on PyPI if you want to give it a shot:

pip install grit-cli

grit setup            # one-time init
grit profile add      # add your identities
grit session set work # set context for this repo

Once your detection rules are in place, you stop running these commands. Grit just... works.

The best developer tools are the ones you stop noticing. Software is complex enough; the right Git identity should just be applied, every time, without costing you a single thought.

Grit is MIT-licensed and open source. Try it on your messiest repo today. If it breaks, open an issue — I'm fixing things within 24 hours right now.

See the code on GitHub →

If you've ever force-pushed to fix a wrong-identity commit — what happened? I'd genuinely love to hear it.