# Samanvya Tripathi

> AI Engineer, Product Builder, and Systems Architect based in Boston, MA.
> MS Computer Science at Northeastern University.
> Portfolio site with 105+ technical blog posts, projects, and photography.

Samanvya (समन्वय) means "co-ordination; the harmonious arrangement of parts working together as one" in Hindi.
He builds intelligent systems, creative interfaces, and bridges the gap between research and production.

## Links

- [Home](https://samanvya.dev/): Main portfolio page
- [Projects](https://samanvya.dev/projects): Selected works
- [Blog](https://samanvya.dev/blog): Technical writing
- [Gallery](https://samanvya.dev/gallery): Photography
- [Resume](https://samanvya.dev/resume): Professional background
- [Full content for LLMs](https://samanvya.dev/llms-full.txt): Detailed version with excerpts

## Blog Posts

- [TurboQuant+ Meets Gemma on a Modal L40S](https://samanvya.dev/blog/turboquant-gemma-l40s): Second pass on TurboQuant+ KV cache compression, this time on a rented L40S across Gemma 3 12B, Gemma 4 E4B, and Gemma 4 26B MoE. One works beautifully, two break in interesting ways.
- [The x Pattern: What npx, uvx, bunx, and pipx Actually Do](https://samanvya.dev/blog/the-x-pattern-npx-uvx): You've typed npx create-react-app a hundred times. But what does the 'x' actually mean? Turns out every major package manager independently invented the same idea.
- [Benchmarking TurboQuant+ KV Cache Compression on Apple Silicon](https://samanvya.dev/blog/turboquant-kv-cache-benchmarks): I tested TurboQuant+ KV cache compression across 1.5B, 7B, and 14B models on an M4 MacBook Air. The speed gains are real, but there are sharp cliffs you need to know about.
- [Claude Code Isn't a Code Editor. It's a New Way to Use a Computer.](https://samanvya.dev/blog/claude-code-new-way-to-use-computer): After a month of writing about Claude Code, here's the thing I keep coming back to: this isn't a developer tool. It's a new interface for computing.
- [Permissions, Security, and Trusting an AI with Your Codebase](https://samanvya.dev/blog/claude-code-permissions-security): Claude Code can edit files, run commands, and push to GitHub. The permission model determines what it can do and when. Here's how I think about trusting an AI agent with my code.
- [What 400+ Sessions Taught Me About Working with Claude Code](https://samanvya.dev/blog/claude-code-400-sessions-lessons): After hundreds of Claude Code sessions across personal projects and production codebases, here are the lessons that took the longest to learn.
- [Custom Commands and Slash Commands: Building Your Own Claude Code CLI](https://samanvya.dev/blog/claude-code-custom-commands): Slash commands turn Claude Code into a personalized CLI. A markdown file becomes a reusable workflow you invoke with a single slash. Here's how to build them.
- [Subagents and Parallel Execution: Making Claude Code 5x Faster](https://samanvya.dev/blog/claude-code-subagents-parallel): Claude Code can spawn autonomous worker agents that run in parallel. Here's how subagents work, when to use them, and why they make complex tasks dramatically faster.
- [Shipping a Feature in 45 Minutes: My Claude Code Workflow End to End](https://samanvya.dev/blog/claude-code-feature-workflow): From memory recall to brainstorm to plan to execution to review to commit. Here's every step of building a real feature with Claude Code, with the actual workflow that makes it fast.
- [Hooks, Statuslines, and the Automation Layer Nobody Talks About](https://samanvya.dev/blog/claude-code-hooks-automation): Hooks let you run shell commands when Claude Code starts, stops, or uses tools. Combined with a custom statusline, they turn Claude Code into a self-monitoring, self-correcting system.
- [MCP Servers Are the Glue Between Claude Code and the Real World](https://samanvya.dev/blog/claude-code-mcp-servers): Model Context Protocol turns Claude Code from a code editor into something that can read Slack, control browsers, and talk to any service. Here's how it works in practice.
- [NotebookLM from the Terminal: Querying Your Docs with Claude Code](https://samanvya.dev/blog/claude-code-notebooklm-terminal): A Claude Code skill that queries Google NotebookLM notebooks directly from the terminal. Source-grounded answers from Gemini, with citations, without opening a browser.
- [I Track Calories and Plan Groceries from My Terminal](https://samanvya.dev/blog/claude-code-lifestyle-skills): Claude Code isn't just for writing software. I built skills that track nutrition and automate grocery shopping at Wegmans, all from the terminal.
- [Skills Are Just Markdown Files and That's What Makes Them Powerful](https://samanvya.dev/blog/claude-code-skills-markdown): Claude Code skills have no SDK, no build step, no runtime. They're markdown files with instructions. That simplicity is exactly why they work.
- [The PR Review Toolkit: Five Agents Reviewing Your Code at Once](https://samanvya.dev/blog/claude-code-pr-review-toolkit): One command spawns five specialized review agents that check your PR for code quality, silent failures, type design, test coverage, and comment accuracy, all in parallel.
- [Ralph Loop: Running Claude Code Autonomously for Hours](https://samanvya.dev/blog/claude-code-ralph-loop): The Ralph Wiggum technique turns Claude Code into an autonomous agent that keeps working until the job is done. Here's how it works, when to use it, and when it's a terrible idea.
- [Superpowers and GSD: How Two Plugins Gave Claude Code a Development Methodology](https://samanvya.dev/blog/claude-code-superpowers-gsd): Without structure, Claude Code is a fast but chaotic coder. Superpowers and GSD impose a methodology (brainstorm, plan, execute, review) that makes the output dramatically better.
- [Claude-Mem Gave Claude Code a Memory and It Changed Everything](https://samanvya.dev/blog/claude-code-memory-claude-mem): Every Claude Code session starts from zero. Claude-mem fixes that by capturing observations, compressing them with AI, and injecting relevant context into future sessions.
- [My Exact Claude Code Setup: Plugins, Skills, and Config](https://samanvya.dev/blog/claude-code-my-exact-setup): A full walkthrough of my .claude/ directory: 19 plugins, 23 skills, custom hooks, and the config that ties it all together. This is the setup I use every day.
- [Plan Mode, Context Windows, and Not Wasting Tokens](https://samanvya.dev/blog/claude-code-plan-mode-context): The 200k context window is your most valuable resource in Claude Code. Here's how to manage it, why plan mode is the most important habit, and what happens when you run out.
- [CLAUDE.md Is the Most Important File in Your Repo](https://samanvya.dev/blog/claude-md-most-important-file): A single markdown file determines whether Claude Code understands your project or fumbles through it. Here's how to write one that actually works.
- [Getting Started with Claude Code: Installation to First Real Output](https://samanvya.dev/blog/claude-code-getting-started): The getting started guide I wish existed when I first installed Claude Code. From npm install to your first real feature, with the mental model that makes everything click.
- [A Month of Claude Code: Why I'm Writing This Series](https://samanvya.dev/blog/month-of-claude-code-intro): I've been using Claude Code daily for months. This is the first of 20 posts breaking down everything I've learned, from setup to skills to running autonomous agents from my terminal.
- [Red/Green TDD with Coding Agents: Why Test-First Matters More](https://samanvya.dev/blog/tdd-with-coding-agents): When AI writes your code, tests become the spec. Red/green TDD isn't just a practice anymore. It's the interface between intent and implementation.
- [LangGraph vs CrewAI vs AutoGen: Building the Same Pipeline Three Ways](https://samanvya.dev/blog/langgraph-vs-crewai-vs-autogen): Three agent frameworks, one task. I built a research-and-report pipeline in each to compare developer experience, flexibility, and production readiness.
- [LLM Guardrails in Practice: Input Validation to Output Filtering](https://samanvya.dev/blog/llm-guardrails-practice): A three-layer guardrail pipeline: validate inputs, constrain execution, filter outputs. Here's what each layer catches and how to build them.
- [Evaluating AI Agents: Beyond 'Does It Work?'](https://samanvya.dev/blog/evaluating-ai-agents): Only 52% of organizations run offline evals for their agents. Here's the multi-layered evaluation strategy that production teams actually use.
- [Function Calling Patterns for Production LLM Agents](https://samanvya.dev/blog/function-calling-production): Function calling connects LLMs to the real world. Here are the patterns that survive production: permission models, error handling, and human-in-the-loop checkpoints.
- [Self-Hosting Qdrant: From Docker Compose to Production](https://samanvya.dev/blog/self-hosting-qdrant): Qdrant gives you the fastest open-source vector search. Here's how to go from docker-compose up to production-ready deployment.
- [Pinecone vs Qdrant vs Weaviate: An Engineer's Decision Framework](https://samanvya.dev/blog/pinecone-vs-qdrant-vs-weaviate): Not another feature matrix. Here are three real deployment scenarios and which vector database fits each one.
- [Reranking: The 20-Line Fix for Bad RAG Results](https://samanvya.dev/blog/reranking-fix-bad-rag): If your RAG pipeline retrieves the wrong chunks, adding a cross-encoder reranker between retrieval and generation can fix it in 20 lines of code.
- [Hybrid Search RAG with Weaviate: Vectors + BM25](https://samanvya.dev/blog/hybrid-search-rag-weaviate): Pure vector search misses exact matches. Pure keyword search misses semantics. Hybrid search combines both, and Weaviate makes it native.
- [Chunking Strategies That Actually Matter for RAG](https://samanvya.dev/blog/rag-chunking-strategies): Your RAG pipeline is only as good as your chunks. Recursive, semantic, and late chunking each have trade-offs that most tutorials skip.
- [The LLM Inference Stack in 2026: From API Call to Response](https://samanvya.dev/blog/llm-inference-stack-2026): The stack for serving LLMs has matured dramatically. Here's the full picture from API gateway to GPU, and where each layer is heading.
- [Context Engineering Is Not Prompt Engineering](https://samanvya.dev/blog/context-engineering-not-prompt): Prompt engineering was the 2023 skill. Context engineering is the 2026 skill. The difference matters more than you think.
- [Structured Output That Actually Works: JSON Mode vs Function Calling](https://samanvya.dev/blog/structured-output-json-mode): Getting reliable JSON from LLMs has been a pain point since GPT-3. Here's the current state of the art and what actually works in production.
- [Prompt Caching: How Anthropic and OpenAI Cut Costs by 90%](https://samanvya.dev/blog/prompt-caching-deep-dive): Prompt caching reuses pre-computed KV tensors for identical prompt prefixes. It's the easiest cost reduction you're not using yet.
- [Tracking Token Costs Before They Blow Up Your Bill](https://samanvya.dev/blog/tracking-token-costs): Output tokens cost 4-8x more than input tokens. If you're not tracking usage by query type and user segment, you're flying blind.
- [LangSmith vs Langfuse vs Braintrust: Picking Your LLM Observability Stack](https://samanvya.dev/blog/langsmith-vs-langfuse): Three platforms, three philosophies. Here's how to choose between LangSmith, Langfuse, and Braintrust for your LLM observability stack.
- [OpenTelemetry for LLM Apps: Tracing Prompts and Tokens](https://samanvya.dev/blog/otel-for-llm-apps): You wouldn't run a web service without tracing. LLM apps -- especially those with [guardrails pipelines](/blog/llm-guardrails-practice) and multi-step agent loops -- shouldn't be different. Here's how OpenTelemetry's GenAI conventions make it work.
- [Building an LLM Gateway with LiteLLM](https://samanvya.dev/blog/llm-gateway-litellm): One API to call OpenAI, Anthropic, and self-hosted models. LiteLLM handles routing, fallbacks, and cost tracking so you don't have to.
- [Self-Hosting LLMs with Ollama: When It Makes Sense](https://samanvya.dev/blog/self-hosting-llms-ollama): Ollama makes running LLMs locally dead simple. But simple and production-ready are different things. Here's where it shines and where it doesn't.
- [vLLM PagedAttention: Why It's the Default for LLM Serving](https://samanvya.dev/blog/vllm-paged-attention): vLLM's PagedAttention manages GPU memory like an OS manages virtual memory. Here's why it's become the standard for serving LLMs.
- [Vibe Coding Is Real but Not What You Think](https://samanvya.dev/blog/vibe-coding-reality): Everyone's talking about vibe coding. After years of using AI to write code, here's what it actually is, what it isn't, and why understanding the code still matters.
- [From Hackathon to Production: What Changes When Prototypes Get Real](https://samanvya.dev/blog/hackathon-to-production): After years of hackathons and production systems, I've learned the gap between a winning demo and a reliable product is mostly about what you choose to worry about.
- [How We Won 1st Place at the MIT LLM Hackathon](https://samanvya.dev/blog/mit-llm-hackathon-first-place): Building Catalyze, a multi-agent system for chemistry research, and winning first place at MIT.
- [MCP Is the USB of AI: Why Model Context Protocol Matters](https://samanvya.dev/blog/mcp-usb-of-ai): Anthropic's Model Context Protocol is doing for AI integrations what USB did for hardware. If you're building agents, this changes everything.
- [DeepSeek Shocked Everyone: What Open-Source AI Means Now](https://samanvya.dev/blog/deepseek-open-source-ai): A Chinese lab just matched GPT-4 performance with open weights at a fraction of the cost. The implications go way beyond model benchmarks.
- [The FastAPI + vLLM + Docker Stack for Serving LLMs](https://samanvya.dev/blog/fastapi-vllm-docker-stack): The production stack for self-hosted LLM serving is maturing fast. Here's the architecture I've landed on after putting models into production at BulkMagic.
- [Sub-200ms Voice AI: The Engineering Behind Real-Time Agents](https://samanvya.dev/blog/sub-200ms-voice-ai): A technical deep-dive into achieving sub-200ms response times in voice AI. Where the latency budget goes and how to claw back every millisecond.
- [Voice AI Architecture: Building Conversational Agents at Scale](https://samanvya.dev/blog/voice-ai-architecture): The full architecture behind voice AI systems. Pipeline design, latency budgets, and why voice is a fundamentally different engineering challenge than chat.
- [Multi-Agent Systems in Production: What Nobody Tells You](https://samanvya.dev/blog/multi-agent-systems-production): Lessons from building multi-agent systems that actually run in production. What works, what doesn't, and what the hype skips over.
- [Building an LLM Microservice with FastAPI and Llama 3.2 on AWS ECS](https://samanvya.dev/blog/llm-microservice-fastapi-llama): How I built a production LLM microservice for product summarization at BulkMagic. FastAPI, Llama 3.2, Docker, and AWS ECS.
- [Multimodal Models Are the New Default: GPT-4V, Gemini, and Beyond](https://samanvya.dev/blog/multimodal-models-2024): In 2024, the best AI models understand text, images, audio, and video natively. As someone with a CV background, this convergence feels like a turning point.
- [The EU AI Act Is Here: What Developers Need to Know](https://samanvya.dev/blog/eu-ai-act-developers): The EU AI Act was finalized this year. As an engineer who builds CV and AI systems, here's my practical take on what it actually means for us.
- [OpenAI o1 and Reasoning Models: A New Paradigm?](https://samanvya.dev/blog/openai-o1-reasoning-models): OpenAI o1 doesn't just generate text. It thinks first. That distinction might be more important than any scaling breakthrough since GPT-3.
- [What an MS in CS Taught Me About the Gap Between Research and Production](https://samanvya.dev/blog/ms-cs-research-vs-production): With my MS at Northeastern nearly done, here's what I actually learned about the space between reading papers and shipping models.
- [Edge AI in 2024: Why On-Device Inference Changes Everything](https://samanvya.dev/blog/edge-ai-2024): Four years after I called edge ML the future, on-device inference is finally mainstream. Here's what changed, what didn't, and where we're headed.
- [YOLOv9 vs RT-DETR: The Transformer Takeover in Object Detection](https://samanvya.dev/blog/yolov9-vs-rt-detr): YOLO's anchor-based speed against DETR's end-to-end elegance. As someone deploying detection models in production, here's how I see the landscape.
- [From PyTorch to Production: The Optimization Pipeline Nobody Talks About](https://samanvya.dev/blog/pytorch-to-production-pipeline): Research papers stop at accuracy metrics. Production starts at deployment constraints. Here's the pipeline that bridges the gap.
- [TFLite vs ONNX Runtime: A Practical Edge AI Comparison](https://samanvya.dev/blog/tflite-vs-onnx-runtime): I deploy models with both TFLite and ONNX Runtime. Here's an honest comparison from someone who deals with the rough edges daily.
- [Transformers for Image Enhancement: Beyond Classification](https://samanvya.dev/blog/transformers-for-image-enhancement): Vision Transformers aren't just for classification anymore. They're rewriting the rules for low-level vision tasks like enhancement and restoration.
- [Pushing Object Detection to 98.6% mAP: Lessons from Production CV](https://samanvya.dev/blog/object-detection-98-map): The last 2% of accuracy is where 80% of the engineering effort goes. Here's what that actually looks like.
- [What Teaching 200 Students Taught Me About Explaining Complex Ideas](https://samanvya.dev/blog/teaching-200-students): A semester as a TA for Intro to Data Science changed how I think about communication, patience, and what it really means to understand something.
- [The Academic Integrity Crisis Nobody Knows How to Solve](https://samanvya.dev/blog/academic-integrity-crisis): As a TA grading 200+ students, I've seen the full spectrum of how ChatGPT is reshaping academic honesty. The problem isn't cheating. It's that we're testing the wrong things.
- [Vector Databases Explained: Pinecone, Chroma, and Beyond](https://samanvya.dev/blog/vector-databases-explained): Vector databases are becoming as fundamental as relational databases. Here's what they are, how they work, and which one to pick for your project.
- [LangChain from Scratch: Building Your First LLM App](https://samanvya.dev/blog/langchain-from-scratch): A step-by-step guide to building a document Q&A app with LangChain. Full code, honest opinions, and a look at where LLM app development is heading.
- [5 Python Libraries Every Data Science Student Should Know in 2023](https://samanvya.dev/blog/python-libs-data-science-2023): The Python data science stack is evolving fast. Some sacred cows are being challenged, and your coursework might not cover the tools that actually matter.
- [The Open-Source LLM Revolution: Why Llama 2 Matters](https://samanvya.dev/blog/open-source-llm-revolution): Meta is about to release Llama 2 with a commercial license. This changes the game for anyone building with LLMs.
- [LoRA Fine-Tuning on a Student Budget: Llama on a Single GPU](https://samanvya.dev/blog/lora-fine-tuning-student-budget): You don't need a GPU cluster to fine-tune an LLM anymore. LoRA makes it possible on a single GPU, and I did it on a grad student's budget.
- [A Beginner's Guide to RAG: Making LLMs Actually Useful](https://samanvya.dev/blog/beginners-guide-to-rag): LLMs hallucinate because they don't know your data. Retrieval-Augmented Generation fixes that. Here's how it works and how to build one.
- [Teaching EDA in the Age of ChatGPT: What Still Matters](https://samanvya.dev/blog/teaching-eda-age-of-chatgpt): ChatGPT can generate a pandas plot in seconds. It cannot tell you which plot to generate. That distinction matters more than people think.
- [How ChatGPT Changed My Data Science Classroom Overnight](https://samanvya.dev/blog/chatgpt-changed-my-classroom): I'm TAing a 200-student data science course and ChatGPT just rewrote the rules. Watching it happen in real time is something else.
- [How to Win Hackathons: Lessons from 3 Wins in 2 Months](https://samanvya.dev/blog/how-to-win-hackathons): I won Best Google Cloud at HackHarvard, Best AI/ML at HackUMass, and mentored at HackGT9 in two months. Here's everything I learned about winning hackathons.
- [ChatGPT Just Dropped and Everything Is About to Change](https://samanvya.dev/blog/chatgpt-just-dropped): ChatGPT launched five days ago and the Northeastern CS Slack hasn't calmed down since. As someone who wrote about GPT-3 two years ago, this feels like the sequel.
- [Whisper by OpenAI: Finally Good Open-Source Speech Recognition](https://samanvya.dev/blog/openai-whisper): OpenAI released Whisper and suddenly open-source speech recognition is actually good. I tried it on Hindi and English and here's what I found.
- [Why I Mentor at Hackathons: Lessons from HackGT9](https://samanvya.dev/blog/mentoring-hackgt9): After back-to-back hackathon wins, I flew to Atlanta to mentor at Georgia Tech's HackGT9. It taught me more than competing ever did.
- [Best AI/ML Hack at HackUMass: Building Meta-Identity](https://samanvya.dev/blog/hackumass-meta-identity): We built a system that clones your voice and face to create a digital twin for the metaverse. Then we won Best AI/ML hack with it.
- [How We Won Best Google Cloud at HackHarvard: Building ReAlive](https://samanvya.dev/blog/hackharvard-realive): 36 hours, a team of four, and an AI that brings old photographs to life with sound. Here's how we built ReAlive.
- [Computer Vision in 2022: The Year Transformers Won](https://samanvya.dev/blog/cv-2022-transformers-won): From ViT curiosity to Swin dominance, how transformers overtook CNNs as the default backbone for vision in a single year.
- [Building AI Prototypes Fast: My Hackathon Tech Stack](https://samanvya.dev/blog/hackathon-tech-stack): The exact tools and libraries I use to go from idea to working AI demo in 24 hours.
- [Diffusion Models Demystified: From DALL-E 2 to Stable Diffusion](https://samanvya.dev/blog/stable-diffusion-practical-guide): Breaking down how diffusion models actually work, from the math to the magic, as someone who spent two years building CV models.
- [From Industry ML Engineer to Grad Student: What Changes](https://samanvya.dev/blog/industry-to-grad-school): After two years shipping models at a startup, I'm going back to school. Here's what I think will change.
- [Why I'm Leaving Industry for Grad School](https://samanvya.dev/blog/leaving-industry-for-grad-school): After two years as an ML engineer in Bangalore, I'm going back to being a student. Here's the honest version of how I got to this decision.
- [MLOps Is Not Optional Anymore: Lessons from Production](https://samanvya.dev/blog/mlops-not-optional): After two years of shipping ML models, I'm convinced that most ML projects fail not because of bad models but because of bad infrastructure around them.
- [Real-ESRGAN Changed Super-Resolution Forever](https://samanvya.dev/blog/real-esrgan-changed-everything): Real-ESRGAN handles real-world degradation in a way previous models never could. As someone who built SR models at Myelin, this one hit different.
- [GitHub Copilot Is Wild: First Impressions from a Working ML Engineer](https://samanvya.dev/blog/github-copilot-first-impressions): I got early access to GitHub Copilot and spent a week using it for actual ML work. Here's what it's like when the AI writes the AI code.
- [CLIP and the Vision-Language Revolution](https://samanvya.dev/blog/clip-vision-language-revolution): OpenAI connected text and images in a way that makes zero-shot classification actually work. This changes everything about how we think about vision models.
- [Two Years as an ML Engineer: From Research to Production](https://samanvya.dev/blog/two-years-ml-engineer): What I've learned going from fresh graduate to production ML engineer. Spoiler: the models are the easy part.
- [Building a Real-Time Anomaly Detection Pipeline for IoT](https://samanvya.dev/blog/realtime-anomaly-detection-iot): From sensor data to alerts in under 2 seconds. Here's the full architecture we built at Myelin for industrial monitoring.
- [Model Quantization in Practice: 4x Speedup Without Losing Accuracy](https://samanvya.dev/blog/model-quantization-in-practice): Our super-resolution model went from 45MB to 11MB. Here's exactly how, with code and real numbers.
- [FPGA vs GPU vs Edge TPU: Choosing the Right ML Hardware](https://samanvya.dev/blog/fpga-vs-gpu-vs-edge-tpu): I tried deploying ML models to all three. Here's an honest comparison from someone who actually suffered through FPGA toolchains.
- [Deploying Anomaly Detection Models on Raspberry Pi](https://samanvya.dev/blog/anomaly-detection-raspberry-pi): Running anomaly detection on a tiny board with 1GB RAM. Here's what worked, what crashed, and what I learned at 2am over SSH.
- [AlphaFold Solved Protein Folding and I Can't Stop Thinking About It](https://samanvya.dev/blog/alphafold-protein-folding): DeepMind just cracked a 50-year-old biology problem with deep learning. This might be the most important ML result of the decade.
- [Vision Transformers Are Coming for CNNs](https://samanvya.dev/blog/vision-transformers-coming-for-cnns): Google just showed that a pure transformer, no convolutions at all, can match the best CNNs on image classification. The implications are huge.
- [GPT-3 Just Dropped and I Have Thoughts](https://samanvya.dev/blog/gpt3-thoughts): OpenAI released a 175 billion parameter language model and the demos are unreal. But as someone who deploys models to phones for a living, I have a slightly different take.
- [From Python to Production: Deploying ML Models with TensorFlow.js](https://samanvya.dev/blog/deploying-ml-with-tfjs): The gap between a trained model in a Jupyter notebook and a working product in someone's browser is bigger than you think. Here's how to bridge it.
- [Docker 101](https://samanvya.dev/blog/docker-101): A beginner-friendly introduction to Docker: what containers are, why they matter, and how to start using them today.
- [Getting Started with Jekyll](https://samanvya.dev/blog/getting-started-with-jekyll): A beginner's guide to Jekyll, the static site generator that turns Markdown into beautiful websites without the complexity.
- [Oh-my-zsh!](https://samanvya.dev/blog/oh-my-zsh): Transform your terminal from boring to beautiful with Oh My Zsh. Autosuggestions, syntax highlighting, and history search in minutes.
- [Best Coding Practices](https://samanvya.dev/blog/best-coding-practices): Foundational development practices every programmer should adopt early, from choosing the right editor to writing proper documentation.
- [Running Super-Resolution in the Browser with TensorFlow.js](https://samanvya.dev/blog/super-resolution-in-the-browser): How to take a trained super-resolution model and run it at interactive speeds in the browser, no server required.
- [Demystifying WebGL for ML Engineers](https://samanvya.dev/blog/webgl-for-ml-engineers): You're running ML models in the browser and it's fast, but do you know why? A look at how WebGL makes GPU-accelerated inference possible on the web.
- [A Practical Guide to Model Optimization for Mobile](https://samanvya.dev/blog/model-optimization-for-mobile): Your model works great on a V100. Now make it run on a phone. Here's what actually works for shrinking and speeding up neural networks.
- [How COVID Is Accelerating On-Device AI](https://samanvya.dev/blog/covid-on-device-ai): A pandemic that shut down the world is quietly pushing the ML industry towards on-device intelligence faster than any roadmap planned.
- [Image Super-Resolution in 2020: From SRCNN to ESRGAN](https://samanvya.dev/blog/image-super-resolution-2020): A practitioner's overview of how image super-resolution evolved from a 3-layer CNN to photorealistic upscaling with GANs.
- [Why Edge ML Is the Future](https://samanvya.dev/blog/why-edge-ml-is-the-future): Cloud inference is great until it isn't. Here's why running ML models on-device is going to matter way more than people think.
- [My Time at NUS, Singapore](https://samanvya.dev/blog/my-time-at-nus-singapore): A 15-day deep dive into Artificial Neural Networks and Big Data at the National University of Singapore, building a Quick Draw app and a Hadoop cluster from scratch.

## Projects

- [Catalyze](https://samanvya.dev/projects/mit-catalyze): AI-powered chemistry assistant with a multi-agent architecture. Specialized agents handle research, protocol generation, lab automation (OpenTrons & Lynx), and safety analysis, backed by ChEMBL database integration. (1st Place - MIT Site LLM Hackathon for Chemistry & Materials)
- [ReAlive](https://samanvya.dev/projects/realive): AI-powered app that brings old photos to life by generating contextual audio. Uses depth mapping, scene recognition, and intelligent audio synthesis to recreate what a moment sounded like. (Best Use of Google Cloud - HackHarvard '22)
- [Meta-Identity](https://samanvya.dev/projects/meta-identity): Create your digital clone for the metaverse. Generates avatars that look, sound, and behave like you using voice cloning, personality replication, and talking-head video generation. (Best AI/ML Hack - HackUMass '22)
- [alignrl](https://samanvya.dev/projects/alignrl): Open-source LLM post-training playbook covering SFT, GRPO, DPO, evaluation, and inference. Published on PyPI with Colab notebooks, a docs site, and 49 passing tests. One pip install to fine-tune any Hugging Face model.
- [Today I Learned](https://samanvya.dev/projects/today-i-learned): A collection of bite-sized lessons on ML and AI topics, each paired with walkthroughs and runnable scripts. Built as a personal learning log that doubles as a reference for anyone exploring the same concepts.
- [TorchSim](https://samanvya.dev/projects/torch-sim): Open-source contributor to a next-gen atomistic simulation engine for ML interatomic potentials. PyTorch-native with GPU-accelerated batched molecular dynamics, FIRE relaxation, and integrations with MACE, Fairchem, and more.
- [AI Clinical Trial Matcher](https://samanvya.dev/projects/ai-clinical-trial): Multi-stage pipeline that matches patients to clinical trials using vector embeddings and LLMs. Ingests trial data, processes patient records, and ranks matches via semantic similarity.
- [YOLO Pilot AI](https://samanvya.dev/projects/yolo-pilot-ai): Autonomous AI that navigates 3D game worlds by reading minimaps and detecting objects in real-time. Drives through GTA V and The Witcher 3 using computer vision and input automation.
- [Twitter Sentiment Analysis](https://samanvya.dev/projects/twitter-sentiment): NLP pipeline for real-time sentiment classification of tweets. Built during a summer internship at NUS Singapore, classifying text polarity using trained ML models.
- [SkillKit](https://samanvya.dev/projects/skillkit): A growing collection of AI coding skills for creative and productivity workflows. Includes image fetching, logo generation, presentations, video/audio processing, and more. Works with Claude Code, Cursor, Windsurf, Copilot, and other AI coding assistants.
- [Image Fetcher](https://samanvya.dev/projects/image-fetcher): Claude Code skill that fetches relevant, high-quality, free-to-use images from the web. Context-aware search, curated picks from Unsplash/Pexels/Pixabay, and direct download to your project with zero config.
- [Presentation Chef](https://samanvya.dev/projects/presentation-chef): Claude Code skill that converts any content into cinematic Keynote-style HTML presentations with glassmorphism, ambient effects, and animations. Zero dependencies, single file output.
- [TL;DR Conditions](https://samanvya.dev/projects/tldr-conditions): "Because who really reads them?" Summarizes Terms & Conditions into plain-English bullet points so you know what you're actually agreeing to.
- [Job Posted Date Plugin](https://samanvya.dev/projects/job-posted-date): Browser plugin that surfaces the actual posting date on job listings, cutting through the noise of recycled and undated postings.
- [The Paddock](https://samanvya.dev/projects/the-paddock): A free, open-source Formula 1 encyclopedia covering 860+ drivers, 100+ teams, 80+ circuits, and 75 years of race data. Replay historic races, simulate alternate championships, compare telemetry, and explore F1 history through interactive visualizations.
- [ResearchProf](https://samanvya.dev/projects/find-research-prof): Wikipedia-style platform for discovering professors by research topic. Search any field and instantly find active researchers with their publications, metrics, and lab info, all powered by the OpenAlex API.
- [JudgeBoard](https://samanvya.dev/projects/judgeboard): Curated directory of hackathons seeking judges and mentors. Filterable by location, topic, and experience level for professionals looking to give back or build an O-1A/EB-1 portfolio.
- [MapVerse](https://samanvya.dev/projects/mapverse): Event discovery platform with role-based access, map-based browsing, and Firebase file storage. RESTful API with admin, user, and guest tiers.
- [Stocks Portfolio Manager](https://samanvya.dev/projects/stocks-pdp): CLI application for creating, managing, and valuating stock portfolios. Supports CSV import, historical price lookup, and persistent data storage.

## Technical Stack

- Framework: Next.js with React and TypeScript
- Styling: Tailwind CSS with custom design tokens
- Content: MDX blog posts with Mermaid diagrams and callout boxes
- Deployment: Vercel

## Expertise

- Machine Learning & Deep Learning (PyTorch, TensorFlow)
- Large Language Models (RAG, agents, fine-tuning, prompt engineering)
- Voice AI (STT, TTS, conversational agents)
- Computer Vision (object detection, super-resolution, transformers)
- Full-Stack Development (React, Next.js, Python, FastAPI, Docker)

## Contact

- Email: samanvyat.work@gmail.com
- GitHub: https://github.com/sacredvoid
- LinkedIn: https://www.linkedin.com/in/samanvya-tripathi/