Skip to main content

AI Agents and the Future of Development: Lessons from a Hackathon

· 7 min read
Scott Havird
Engineer

What happens when you give a small team of developers one week, a pile of AI tools, and the audacity to think we could build something meaningful? This is our story from the KOLO AI Hackathon – a journey into what agent-led development might actually look like.

The Question That Started Everything

"How long do you think it'll be before software engineers are no longer writing any code?"

That question hung in the air during our DevEx Community Talks session, and honestly, it felt both thrilling and terrifying. Dario Amodei, CEO and cofounder of Anthropic, recently predicted we'll reach a point where "AI is writing 90% of the code" in just 3-6 months, and "essentially all of the code" within 12 months.

But predictions are one thing. Actually working with AI agents to build something real? That's where the rubber meets the road.

The Experiment

Our team – Shad Ahmed (frontend/backend), Robert Bethke (backend/SME), Zac Hamilton (infrastructure), and myself (app architecture/frontend) – had one week to answer a killer question: What does agent-led development look like, and what practices are required to do it well?

The constraints were beautifully simple:

  • One week of dedicated time
  • Small core team of four
  • AI agents as our primary coding tools
  • Product and design teams available to assist
  • Goal: Build a PWA frontend and API backend

No safety net. No fallback to "the old way." Just us, the agents, and whatever we could figure out together.

The Reality Check

Here's what nobody tells you about working with AI agents at scale: the real-world challenges hit you like a freight train.

Source Code Fragmentation became our first enemy. When agents are generating code across multiple files and contexts, keeping everything coherent requires discipline we didn't know we needed.

No Rules + No Tests + No Planning = Code Chaos! The freedom to move fast with AI becomes a curse when you realize you've built a beautiful house with no foundation.

Too Many Tool Choices paralyzed us more than once. When everything is possible, decision fatigue becomes real.

Risk of Data Loss kept us awake at night. How do you version control when your "developer" is an AI that might hallucinate away three hours of work?

Generating an Avalanche of Code to Review – this one surprised us. We thought AI would reduce our review burden. Instead, we found ourselves drowning in generated code that worked but wasn't necessarily right.

The Architecture That Saved Us

When the chaos threatened to consume us, we fell back on principles that have guided good software development for decades – but with a twist.

We built a monorepo architecture with:

  • Progressive Web App (React)
  • Component Library (React with atomic design principles)
  • Shared Packages (UI components and shared types/utilities)
  • Backend Go API Server
  • MySQL Database

The key insight? Modular and flexible design isn't just nice-to-have with AI agents – it's survival. When an agent can rewrite entire files in seconds, having clear boundaries and contracts becomes critical.

The Developer Experience Revolution

One click to run the entire development environment. That's what we achieved with Turborepo and PNPM, and it felt like magic.

But the real breakthrough was understanding that agent-ready architecture means designing for collaboration between humans and AI. Every component needed to be:

  • Self-contained enough for an agent to understand in isolation
  • Well-documented enough for context switching
  • Modular enough to be safely modified

Rules, Rules, Rules

"Rules, rules, rules" became our mantra. Cursor Rules weren't just helpful – they were absolutely essential.

What are Cursor Rules? Think of them as persistent, scoped instructions for your codebase that enforce conventions, reduce hallucinations, and maintain consistency. They're applied:

  • Always (project-wide standards)
  • Auto-attached (smart contextual rules)
  • Agent-requested (when the AI needs guidance)
  • Manual (when we needed to step in)

Without these guardrails, we would have drowned in inconsistent code styles, broken naming conventions, and architectural drift.

The Workflow That Actually Worked

Our Execution & Iteration Workflow evolved into something beautiful:

  1. Prompt (with context)
  2. MCP (Model Context Protocol for enhanced agent capabilities)
  3. Code (generation/modification)
  4. Write Test (validation)
  5. Update Rules (learn and improve)
  6. Review (human oversight)
  7. Merge (integrate)

The key insight? Add context early, test everything, and "rules, rules, rules." One-shot development is rare – iteration is everything.

The Tools That Made the Difference

  • Cursor AI – our primary development environment
  • VS Code Extensions (Roo Code) – for specialized tasks
  • Player Zero – for testing and debugging
  • Figma (with MCP integration!) – design-to-code pipeline
  • Model Context Protocol (MCP) – the secret sauce for agent collaboration

Working Together: Human + AI

The magic happened when we stopped thinking about AI as a replacement and started treating it as a collaboration partner.

IaC (Infrastructure as Code) let us version control our entire environment. Components & Libraries gave us reusable building blocks. PWA/API Mocks let us develop frontend and backend in parallel. Backend Integration happened seamlessly because we'd designed for it.

Project Management in the AI Age

We captured our task list in GitHub Issues and used GitHub Kanban boards. Simple, but effective. The key was keeping tasks small enough for agents to handle independently while maintaining clear dependencies between components.

Aha Moments

Three breakthroughs changed everything:

  1. Trivial Code Conversion! What used to take hours now takes minutes. Converting between frameworks, updating APIs, refactoring – all became almost effortless.

  2. Easily adopt accessibility standards. AI agents don't get lazy about alt text or ARIA labels. They just implement them consistently.

  3. We can take bigger swings. When the cost of iteration approaches zero, you can experiment with architectural decisions that would have been too risky before.

Lessons Learned (The Hard Way)

Rules were missed → Code Review became critical. When agents drift from standards, human oversight catches it.

Old Context = Terraform Troubles → Context7 MCP Server to the rescue. Keeping agents working with fresh, relevant context isn't just helpful – it's essential.

Clunky UI import process → Figma MCP Server. Direct design-to-code pipelines eliminate the tedious translation layer.

The Future We're Building

"Embrace creativity – This new paradigm allows for a lot more experimentation!"

Pre-planning becomes even more important when the cost of implementation drops to near zero. Architecture decisions matter more, not less, because you can afford to build the right thing instead of just the thing that works.

Don't be scared. This isn't about replacement – it's about amplification. Where is the industry going? There will be many winners and losers, and it'll be years before consolidation occurs. But capabilities are advancing rapidly: Parallel Agents → Claude Code (terminal) → MCP/A2A/etc.

We're all passengers on this beautiful planet sailing through the same technological storm together. Some are enjoying the pleasure ships while others are treading water, gasping for air, and struggling to adapt.

The teams that learn to work with AI agents instead of against them – or instead of ignoring them – will find themselves with superpowers. The rest will find themselves left behind.

I hope to see you all on the peaceful shoreline of this new development paradigm, one line of AI-generated code at a time.