YYash Rahurikar

Yash Rahurikar

Hello, I'm Yash. I'm the founder of PieceOfCode Labs, where I build AI products end to end — Nands, a hub for tech news, events, hackathons and community discussions; Marian, a Chrome extension for highlighting the web and asking questions about what you've saved; and Docsmith, shared memory for teams. I'm also a product engineer at Tweeny Technologies.

I started out as a Project Engineer in industrial automation — a world of PLCs, control panels and machines on factory floors. It taught me a lot about systems that have to work, because when they don't, something physical stops moving.

But the thing I kept coming back to was wanting to build products people actually use — software you could put in someone's hands, watch them use, and improve the next week. Automation projects didn't have that loop. So I moved into software, and I've been building products ever since.

I build across agentic AI systems, voice AI and full-stack applications, but the throughline is product engineering. I care about the whole product, not just the code: why it should exist, who it's for, and whether it actually solves the problem.

Lately I've been going deep on AI/ML — building agentic systems with LangChain and CrewAI — and I've recently started learning robotics. I write about it as I go.

If any of this overlaps with what you're building or curious about, get in touch — I like talking about software, products, AI and robotics with people who are into the same things.

What I'm working on now

As of September 2026

Voice AI

Voice agents you can actually hold a conversation with. Speech in, a model thinking, speech back out — and all of it fast enough that nobody feels like they're on a walkie-talkie.

  • Speech-to-text. Getting words out of audio quickly enough to keep up with someone mid-sentence.

  • Text-to-speech. Voices that don't sound like a robot, and getting that first bit of sound out fast.

  • Turn-taking. Working out when someone has actually finished, rather than just stopped for breath.

  • Interruptions. Letting people cut in, and stopping cleanly when they do.

  • Latency. Shaving time off every stage until the reply lands in a natural pause.

  • Transport. Moving the audio about in real time, over WebRTC.

CascadeSpeech-to-speech (S2S)InboundOutboundEvalsGuardrailsSimulationsTesting

Harness engineering

Everything around the model, which turns out to be most of the work. What the agent sees, what it can reach for, and what it does when something goes wrong.

  • Context management. Deciding what the model actually sees each turn — summarising, trimming, and only handing it tools when it needs them.

  • Agentic RAG. Letting the agent decide when to go looking, rewrite its own question, and check what came back before trusting it.

  • Tools & MCP. Small tools that explain themselves and fail clearly, handed over through MCP.

  • Memory & state. Writing progress down so the agent can read it back later, instead of hoping it still remembers.

  • Evals & verification. Making it show its working before it's allowed to say it's done.

  • Guardrails. Permissions, checks on the way in and out, and a person in the loop when the action is risky.

  • Observability. Traces of every model call, tool call and lookup, so when it goes wrong you can see exactly where.

  • Orchestration. Control flow, retries and subagents, for when one pass through isn't enough.

Models

The models themselves — the part the harness deliberately leaves out. Mostly I'm seeing how small a model can get away with being and still do the job.

  • LLMs. Playing with which model suits which job, and what each one costs in waiting as well as money.

  • SLMs. Small models — a few hundred million parameters up to a few billion — that run on hardware I own.

  • Decision models. Playing around with where Jev fits: anywhere the answer is a pick from a list rather than an essay, with a confidence attached.

  • Reasoning. Models that think before they answer, and working out when that extra wait actually earns its keep.

  • Fine-tuning. LoRA on a laptop GPU, over an afternoon, rather than booking a cluster.

  • Distillation. Letting a big model teach a small one — copying the whole hunch, not just the final answer.

  • Inference. Quantised and running locally. Milliseconds instead of a round trip, and nothing to pay per call.

Product engineering

Writing the code is one part of the job. These are the others — the work that decides whether the code is worth writing.

01

Discovery

Talking to the people who have the problem, working out what it actually is, and whether it's worth solving at all.

02

Product spec

Writing it down before anyone builds: what the problem is, who it's for, what we're deliberately not doing, and how we'll know it worked.

03

Scoping

Cutting it back to the smallest thing that tells us something, then ordering the rest by what we'd learn next.

04

Architecture

Deciding the shape of the thing: the data model, the services, and where AI genuinely helps rather than where it just sounds good.

05

Build

All of it — front end, backend, the AI bits, and whatever it runs on.

06

Ship & measure

Getting it out, then watching what people actually do with it. For anything with AI in it, that means evals, not a good demo.

07

Iterate

Taking what we learned back to the spec, and going round again.

Technologies

The areas I work in, and the tools I reach for in each.

Voice AI

Agents you can talk to, fast enough that it feels like a conversation.

PipecatDailyLiveKitDeepgramElevenLabs

AI Agents

Agents, and all the scaffolding around them that decides whether they're dependable.

LangChainLangGraphLangSmithStrands AgentsMCP

RAG & Search

Getting the right passage in front of the model — finding it, ranking it, and throwing away the rest.

Full-stack

What I actually ship on: the web, APIs, and the browser.

Next.jsTypeScriptPythonFastAPIMongoDBChrome extensions