Carn.ie: Top 6 at the World's Biggest Claude Code Hackathon

Claude Code launched in February 2025 as a simple terminal tool. One year later, it had become one of the most talked-about developer tools in the world. To celebrate the anniversary, Anthropic partnered with Cerebral Valley to host something ambitious: a global hackathon centred on their latest model, Opus 4.6, with its million-token context window and enhanced agentic coding capabilities.

The response was staggering. Over 13,000 developers, designers, and builders from every corner of the world applied for a spot. Anthropic selected 500. Each received $500 in Claude API credits and a simple brief: build something remarkable in six days, from 10 to 16 February 2026. Teams could be a maximum of two people.

The stakes were real. $100,000 in Claude API credits awaited the winning projects. But the true prize was something rarer: the top entries would be invited to San Francisco to present their work at Claude Code's 1st birthday party, live on stage, in front of 500 people and the team that built Claude Code itself.

The judging panel reflected the calibre of the event. Boris Cherny, the creator of Claude Code. Cat Wu. Thariq Shihpar. Lydia Hallie. Ado Kukic. These weren't casual observers. They were people who understood, deeply, what it takes to build something that works, and more importantly, something that matters.

Among the 500 selected builders was Kevin Collins, joining from Dublin, Ireland. He entered solo. No teammate. Just a laptop, $500 in API credits, a deep familiarity with Claude Code from running Ireland's Claude Code community, and an idea that had been forming for months: what if AI could help find missing people?

Every year, thousands of people go missing in wilderness environments. Hikers who lose their way in the mountains. Climbers caught in sudden weather changes. Elderly people who wander from care facilities into rural areas. Children who stray from campsites. In Ireland alone, mountain rescue teams respond to hundreds of callouts annually, often in conditions that make searching painfully slow.

Traditional search and rescue is a numbers game played against a ticking clock. Teams of volunteers spread out across terrain, walking grid patterns, calling out, scanning with torches in the dark. Helicopters can cover more ground but are expensive, weather-dependent, and often unavailable when needed most. The search area expands with every passing hour. The probability of a positive outcome shrinks.

This is the problem Carn was built to solve. Not with more volunteers or bigger budgets, but with a fundamentally different approach: put an AI in the sky and let it do what humans physically cannot.

Carn is not a toy. It is not a proof of concept built for a demo and then forgotten. It is an autonomous search and rescue platform designed for the worst moments of people's lives, the moments when a family is waiting and every minute stretches into an eternity. That purpose shaped every decision Kevin made during the hackathon, and it shaped the way the judges saw it.

The core idea behind Carn is deceptively simple. A drone flies over the search area. Its cameras look down. AI analyses what the cameras see. When it spots a person, it sends the exact location to rescue teams. In practice, making this work reliably is anything but simple, but the general approach is intuitive enough that anyone can understand it.

Here is how a Carn mission unfolds.

The beauty of this approach is that it transforms search and rescue from a manpower problem into a technology problem. A single drone with Carn can cover more ground in an hour than a team of twenty volunteers can cover in a day. It can see in the dark. It does not get tired. It does not miss things because it has been walking for eight hours in the rain. And when it finds someone, there is no ambiguity: here are the coordinates, go get them.

That is the vision Kevin brought to the hackathon. Not another chatbot. Not another developer tool. A system that could, quite literally, save someone's life.

The hackathon opened on 10 February 2026. Kevin had six days. No teammate. $500 in Claude API credits. And a vision for something that most people would say is impossible to build alone in less than a week.

Building Carn was not like building a web app or a chatbot wrapper. This was a system that needed to handle autonomous drone flight planning, real-time image processing across two camera systems, AI-powered human detection in complex terrain, GPS coordinate calculation from aerial perspectives, and a natural language mission control interface. Each of these is a significant engineering challenge on its own. Kevin had to build all of them, integrate them into a coherent platform, and make it work well enough to impress a panel of judges who had seen 500 entries.

The approach was methodical. Start with the core detection pipeline, because without reliable detection nothing else matters. Build out the mission planning interface. Connect the GPS calculation system. Layer in the thermal imaging support. Polish the Mission Control interface last, once the underlying systems are solid.

Claude's Opus 4.6 model, with its million-token context window, proved essential. The context window meant Kevin could feed the model entire system architectures, documentation for drone APIs, image processing pipelines, and geospatial calculation libraries all at once. Instead of working with a model that forgot what you told it three prompts ago, he was working with one that could hold the entire project in its head simultaneously. For a solo builder tackling a complex multi-system project in six days, that was the difference between possible and impossible.

“When you are building something alone and you have six days, you cannot afford to explain the same context to your tools over and over. Opus 4.6's context window meant I could have a genuine collaborator that understood the full picture of what I was building. That changed everything.”

There is a particular kind of pressure that comes from building something that matters under a deadline. When you are making a to-do app, you can cut corners and nobody gets hurt. When you are building a system designed to find missing people, the quality has to be real. The detections have to be accurate. The GPS coordinates have to be precise. The mission planning has to be intelligent. You are building for the worst day of someone's life, and that responsibility does not take a break just because you are in a hackathon.

Kevin submitted Carn on 16 February 2026. Six days. Solo. A complete autonomous drone search and rescue platform. Then he waited.

The email arrived a few days after submission. Carn had been selected as one of the top 6 entries. Out of 13,000 applicants. Out of 500 selected builders. Six projects had risen to the top, and Kevin was invited to San Francisco to present Carn live on stage at Claude Code's 1st birthday party on 21 February 2026.

Flying from Dublin to San Francisco to present at an Anthropic event is not something you do casually. But the invitation was clear: the top 6 would present their projects to an audience of approximately 500 people, including the Anthropic team, Cerebral Valley community members, and builders from around the world.

The birthday party itself was a landmark moment for the Claude Code community. One year earlier, Claude Code had been a simple terminal tool. Now it was a global ecosystem, and the room in San Francisco reflected that. Builders, engineers, founders, and the Anthropic team gathered to celebrate what had been built in a single year, and to see what the community was capable of creating.

Kevin took the stage alongside the other top 6 entries. Elisa by Jon McBee, a visual programming environment designed to teach children to code. Zeppelin by Anup Ghatage. FenceFlow by Nour Desouki. CrossBeam by Mike Brown, which streamlined California's notoriously slow permitting process. And postvisit.ai by Michal Nedoszytko, which converts medical visit transcripts into personalised health guidance. Each project was remarkable in its own right. Each had found a genuine problem and built a genuine solution with Claude.

And then there was Carn. An autonomous drone search and rescue platform built by a solo Irish developer in six days. The kind of project that makes a room go quiet when you explain what it does and why it matters.

Presenting in front of 500 people is one thing. Presenting something that could save lives, in front of the people who built the tool that made it possible, is another thing entirely. Kevin met Boris Cherny, the creator of Claude Code, along with his number two. He met Ado and Jason Bigman. He connected with builders from around the world who had all, independently, decided to use AI to solve problems that actually matter.

There is a particular feeling that comes from standing in a room full of people who understand what you have built and why it matters. Not investors looking for returns. Not managers looking for productivity gains. Builders. People who know how hard it is to make something work, and who recognise when the something in question is worth making. That is what San Francisco felt like.

Hackathon projects have a well-known lifecycle. You build something amazing under pressure. You present it. People clap. And then it sits in a GitHub repository gathering dust, a monument to what could have been. Everyone knows this pattern. Most hackathon projects never become real products.

Carn broke that pattern.

Following the hackathon and the San Francisco presentation, the decision was clear: this project is too important to leave as a demo. Carn is being taken forward into production. The goal is to bridge the gap between “impressive hackathon project” and “technology that can actually go out and find missing people.” Software alone can demo beautifully. Software paired with the right hardware can save lives.

If you want to help with the project or learn more about the story behind Carn, visit carn.ie/story.

Not a hackathon novelty. Not a portfolio piece. A real search and rescue capability that could be deployed when someone goes missing in the mountains, in the forests, in the places where time is the enemy and technology is the only thing fast enough to fight it.

The next challenge, and the one Kevin is actively working on now, is getting the software and hardware to work together: running the AI detection models directly on the drone's onboard compute.

This is not a nice-to-have. It is a fundamental requirement for real search and rescue. Consider where missing persons are typically lost: mountains, forests, remote valleys, coastal cliffs. These are places where mobile phone coverage is unreliable at best and nonexistent at worst. If the drone needs to stream video back to a ground station for processing, the system fails the moment it flies into an area with no connectivity, which is precisely where missing people tend to be.

Running the AI models on the drone itself solves this entirely. The drone processes its own camera feeds. It makes its own detection decisions. It calculates GPS coordinates locally. The only data it needs to send back is the alert: “Person detected at these coordinates.” That is a tiny packet of data that can be transmitted over the weakest of signals, or even stored and relayed when the drone returns to an area with connectivity.

There is also the latency question. In cloud-based processing, video frames need to be captured, compressed, transmitted to a server, processed by the model, and then results sent back. Even with good connectivity, this round trip introduces delay. When the drone is flying over terrain at speed, delay means the drone has moved on by the time the detection comes back. On-device processing eliminates this entirely. The detection happens where the seeing happens, in real time.

Kevin is working with the Carn team to get these models optimised and running on the drone hardware. This is the final technical hurdle between Carn as a demonstrated capability and Carn as a deployed system. The models need to be efficient enough to run on embedded compute. The inference needs to be fast enough for real-time detection. The power consumption needs to be low enough that detection does not significantly reduce flight time. These are solvable problems, and they are being solved.

Carn is not an isolated achievement. It is the latest chapter in a remarkable hackathon journey that has taken Kevin from Dublin to the global stage in less than six months.

Three major competitions. Three exceptional results. But look closer and you see something more important than a winning streak. Each project tackled a completely different domain: education, telecommunications, search and rescue. The common thread is not the technology. It is the approach: identify a real problem, build a real solution, execute under pressure, and create something that actually works.

But of the three, Carn is different. GradGenie saves time and money. ARANO optimises networks. Carn saves lives. That is a category of its own.

There is a conversation happening in the AI industry right now that most people are tired of: what is AI actually for? The dominant answers, so far, have been variations of “making things faster” and “making things cheaper.” Faster code generation. Cheaper customer support. More efficient ad targeting. These are fine goals, but they are not inspiring ones.

Carn represents a different answer. AI is for finding the hiker who did not come home. AI is for seeing in the dark when human eyes cannot. AI is for being in the air when every helicopter is grounded by weather. AI is for turning “we searched everywhere we could” into “we found them.”

This is not a theoretical argument. This is a platform with detection capabilities, thermal imaging, GPS alerting, and mission control being taken into production. It is AI for genuine good, built by someone who has consistently demonstrated that the best use of cutting-edge technology is applying it to problems that actually matter.

At Echofold, this philosophy runs through everything we do. From the AI for Good hackathon we helped organise in Dublin, where 50+ builders created 33 live projects in a single evening, to the Claude Code community we run for Irish developers, to the events we host for builders who believe technology should serve people, not just shareholders.

Carn is the purest expression of that belief so far. Technology that goes into the sky to bring people home. That is what AI should be for.

While in San Francisco, Kevin also made a quick stop at the Manus offices. Having organised Dublin's AI for Good hackathon with Manus just weeks earlier, it was a chance to connect in person with a team whose tools had helped 50+ builders create 33 live projects in a single evening back in Dublin.

The Carn team is working toward production readiness. The goal has not changed since day one of the hackathon: put this technology into the field and use it to find missing people.

There will be more testing. More optimisation. More iteration. The gap between “works in a demo” and “works in a rainstorm on a mountainside at 2am” is significant, and closing it requires the same discipline and determination that won the hackathon placement in the first place.

But the trajectory is clear. A six-day hackathon project has become a real platform with a real team working to deploy it. Carn started as an idea about what AI could do if pointed at a problem that truly matters. It is becoming an answer. If you want to help or learn more, visit carn.ie/story.