i was lazy about internships for the summer and got one late, only for it to fall through last minute. welp! so i spent most of the summer building. my goal at the start was simple: get better at agentic coding, and also dive into computing fundamentals.

i split the projects into two categories. the agentic ones are definitely more feature-complete. my main work for most of them was prompting, testing, and making sure the output was actually what i wanted. the manual ones are where i wrote 80-90% of the code myself, mostly in c++, and only used ai to build interfaces after the fact. most of the manual ones are also fundamental projects to understand how something works and don't have a ton of "cool" features lol. before this summer, i was a python buff but i started writing c++ after i saw a tutorial online and it was in c++. became addicted since and now most of my projects are c++.

agentic coding projects

hn search

this was my capstone after a month of going deep on how search engines actually work. it's a chrome extension that uses a hybrid of bm25 and semantic reranking to search hacker news. i initially built my own crawler to index posts, but rate limiting made it too slow and stale, so i switched to algolia's api to fetch candidates, then applied a custom bm25 algorithm that weights post scores alongside text relevance, and finally used a lightweight on-device embedding model to rerank the top results. the hardest part was getting the spotlight-style interface right. took several iterations with composer 2.5 but ended up clean and intuitive.

screenstream

built as a 24-hour take-home for a yc-backed startup. they build fast inference for vision-language models, so i used their platform to power a chrome extension for people with visual impairments. when you hover over text, it reads it aloud. hover over an image and it describes it: colors, layout, everything. the tricky part for this was finding the right hybrid architecture to use their platform's strengths without sacrificing speed. they loved the project and i made it to a cto interview. didn't get the offer, but it was one of the more meaningful things i built this summer.

ambient conductor

totally a fun side project. the idea: conduct music with your hands through a webcam. i used meta's demucs model to split songs into their stems, mediapipe to track right-hand movement, and then mixed the components in real time based on gesture. my cousin and aunt couldn't stop laughing when they tried it. it works like an actual conductor: no special hardware needed beyond a webcam.

snapshot

a solo hackathon project i did in 3-4 hours just to tinker with world models. i used world labs' spark models to turn a static image into a simple game environment where you shoot ghosts. didn't win, but i was more happy at tinkering with world models tbh. got free merch from the hackathon as well so a W is a W lol.

contractbot

this was my first attempt at building an open source tool. i got the insp from yc's request for startups list. it's a tool that diffs your approved api baselines against an external api's openapi schema to detect breaking changes and notify you automatically. still a work in progress. turns out getting users is genuinely hard. planning to keep iterating and collecting feedback.

pronto

built at a hackathon organized by vista for their portfolio companies. i was the youngest person on a team of senior engineers so they were hesitant to give me much at first. when i finished the first task they gave me and kept asking for more, they gave me real autonomy. we built an ai-powered billing platform for small business owners. i handled invoice payment logic and built a rag tool to keep the system compliant. we placed third out of 24 teams yay!!!

semanticgrep

a natural language search tool for codebases. you index a repo, then ask questions in plain english about where things are implemented. i used cohere's embedding and rerank apis because their free tier is generous and the rerank model made search quality noticeably better. the backstory behind this isn't fully resolved yet, so maybe i'll write on it later :)

manual coding projects

limit order book — c++

i got interested in trading software after participating in the jane street focus program, so i built a representation of one of the matching games we played. it's a limit order book that matches buys to sells based on price-time priority, with order cancellation support. not my most complex project at all, but it taught me something unexpected: a month later when i hit the heap section of neetcode 150, i breezed through every question because i had already used a priority queue with custom comparison and actually understood why it worked.

monte carlo options pricer — c++

after taking an mit ocw course on monte carlo simulations, i wanted somewhere to apply it. this project prices european and asian options using monte carlo methods, and i added antithetic variates to reduce variance. when i was done, i measured and the spread dropped from 0.74 to 0.15 across repeated runs at the same simulation count. probably my most heavy math & trading side project?

recursive descent expression evaluator — c++

wanted to understand how programming languages actually work under the hood so i built a tiny one. so i started with a lexer that reads raw source code character by character and breaks it into tokens — numbers, operators, identifiers. then i added a parser on top that takes those tokens and builds a tree representing the actual math, respecting operator precedence so multiplication happens before addition. then an evaluator that walks the tree and spits out the answer. this was among my earliest work with recursion and ngl, i was so lost for a while but it clicked after a while. once i saw why each function calls the next one down, it just made sense.

http server — c++

claude suggested this one when i said i wanted something hard and fundamental. ngl, it was both. the hardest part about it wasn't even the code: it was the concepts. i spent about a week reading beej's guide to socket programming before writing a single line. the server runs on posix sockets: get a file descriptor, bind it to a port, listen for connections, accept each one and create a new descriptor for it, parse the request, serve the response. i also implemented a thread pool so the server doesn't spin up and destroy an unbounded number of threads under load. no external libraries. genuinely proud of this one. lowkey think it was my most "low-level" project.

huffman file compressor — c++ & webassembly

i read an x thread on how file compression works and decided to build one. the huffman algorithm itself wasn't hard tbh. this summer, i'd done enough tree work and recursion so the implementation came naturally. the hard part was bit manipulation: packing bits into bytes when encoding and unpacking them correctly when decoding. it was my first time doing it, and it took a while to get right. after it worked, i compiled the c++ to webassembly with emscripten so it runs entirely in the browser, had the frontend built and wired up by an ai tool, and deployed it. i also added lz77 as a second compression option for file types where huffman alone doesn't do much.

unix shell — c++

a short project i did to understand how shells actually work. the project supports most standard operations: command execution, piping, input/output redirection, and built-in commands like cd and exit. the key insight i gained from this was understanding why some commands have to be built into the shell itself (cd changes the shell's own working directory: a child process can't do that). learned execvp, fork, wait, pipe, and dup2. it was short but i was able to get a real mental model of what happens between typing a command and seeing output.

autocomplete system — python

wrote a blog post about how autocomplete works and wanted to actually build what i was writing about rather than just explain it theoretically. the system has two parts. so i used a special data structure called a "trie": a tree structure where each node represents a character, so typing "th" instantly narrows you down to only words that start with "th" without scanning the entire dictionary. the second part is a bigram language model in python trained on the sherlock holmes corpus: it learns which words tend to follow other words, so the suggestions aren't just "words that start with what you typed" but "words that are likely given what you've been typing." when both are combined, the autocomplete gets more accurate the more context it has, which depicts very accurately how most phone keyboard works. was fun seeing the model predict "holmes" after "sherlock" with high confidence. i was stubbornly going to build this in python initially but after a while, i was like "ooofff, this is tuff". just switched to python and saved myself a needless headache.

reflection

looking at all the projects, i am lowkey amazed at how much i managed to build lol. it wasn't even intentional or anything. i just kept building and learning. i also enjoy coding and ideating so maybe that made it easier for me to spend an average of 8 - 9 hours daily doing smth related to coding? but trust, i wasn't tryna spam projects lol.

i also think that's an advantage of AI ? it helped me build the more advanced ones faster. some of those projects were just me prompting for 1 day tbh. for the ones where i wrote code myself, AI was helpful in explaining the concepts to me so i understand better and also debugging the code. this generation has the advantage of a 24 hours tutor. if you're on claude's free tier, technically around 10 - 15 hours thanks to anthropis's limits. ugh!

then again, 3 months is long tbh. def not leaving the internship search late anymore. this 3 months were fun but also not fun sometimes. coding alone can be lonely lol.

anyways it was a very good 3 months of learning. let's see what the future has in store…