I'm a cofounder working full-time on another product. I don't have 4-hour coding blocks to dedicate to side projects. But I had a clear idea: build a booking and class management system for the martial arts academy I train at. I've been working with my coach to understand the real needs of a small academy — scheduling, attendance, family accounts, membership plans — and I wanted to bring that to life.

I used Devin to build it. Not as a code autocomplete tool, but as an engineering partner I could direct from my phone between meetings or after training. Here's what that actually looked like over the past month.

The project: GymClass

A full-stack booking system for martial arts academies. TypeScript, Bun, React, Hono, tRPC, Drizzle ORM, Neon Postgres, deployed on Cloudflare. Multiple user roles (admins, coaches, students, parents), class scheduling, attendance tracking, trial bookings, family account management, membership plans with booking limits.

This isn't a toy project. It's a real app with real users at our academy.

What surprised me: Devin is really good at refactors

I did a couple of significant refactors with Devin. One was migrating from Vitest to Bun's built-in test runner. I dropped a message: "I'm using Bun to run the app, but use vitest to run tests. Can you do a plan to migrate to Bun for tests too?"

Devin explored the codebase first. It came back and told me: "You're already 87.5% done — 42 of 48 test files already import from bun:test. Only 6 files still use vitest." Then it identified which were trivial swaps and which needed mock rewrites. When I said "go ahead," it did the migration, opened a PR, and when another PR I merged caused a conflict, it rebased cleanly and got CI green again.

What impressed me wasn't just the result — it was that Devin checked its own work along the way. It ran the test suite, verified there were no regressions, identified pre-existing failures vs. its own changes, and reported back clearly.

The same thing happened when I explored migrating my hosting from a self-hosted setup (Coolify on Contabo) to managed services. Devin researched my current architecture, proposed a phased migration plan with rollback strategies, answered my questions about latency trade-offs for my users in US, Panama, and Spain, and created tracked issues for each step. All from a conversation.

The killer feature: breaking huge tasks into small, testable steps

One of the first things I gave Devin was the full scope of what I wanted — user personas, user stories, the whole picture. Devin didn't try to build everything at once. It organized the information into vertical application slices and broke them into separate, dependent PRs.

For example, when I asked for parent-child account management (parents managing bookings for their kids), Devin:

Researched state-of-the-art approaches (Mindbody, ClassPass, etc.)

Proposed a "Linked Profiles" architecture

Created a phased PRD with 6 issues, each with clear dependencies

Executed them one by one — schema first, then booking delegation, then parent UI, then admin migration flow

Each PR was self-contained — passing CI, tested, and reviewable on its own

When I said "execute all the issues one by one and test them," Devin ran this loop: work the issue → open PR → wait for CI → test → ask me to merge → move to next. Six PRs, all merged, all building on each other correctly.

Same pattern with performance work: I asked Devin to review the app for stability issues. It found 15 problems across 3 priority tiers, created 14 PRs (one combined two related fixes), ran the full test suite with all changes merged together, and verified specific behaviors (like rate limiting actually blocking the 6th request). When I pointed out the rate limits were too conservative, it adjusted them and explained why.

"Test the app" — orchestrating from my phone

Before I merged each PR, Devin offered to visually test the feature by spinning up the app and recording a video. I could watch a recording of my app running in the cloud, see the feature working, and decide whether to merge — all from my phone.

This changed how I work on side projects. I'm not sitting at my laptop reviewing diffs for hours. I'm reading a 2-sentence summary, watching a 30-second video, and tapping "merge." Then Devin picks up the next issue.

The loop was: Devin messages me that a PR is ready → I check the video → I merge → Devin continues. I did entire multi-PR features this way while commuting or waiting for my daughters outside their activities.

What I got done in a month

Full class instance materialization system (migrated from virtual occurrences to a proper booking architecture)

Parent-child family account management with admin migration flows

15 performance and stability improvements

Vitest to Bun test runner migration

Full CI dev pipeline to test features in isolation

Academy membership plans with class limits and booking enforcement

Attendee visibility features

Deployment architecture research and migration planning

A WhatsApp trial class booking connector (research phase)

All while working full-time on another product.

Being honest about the experience

This worked well for me because I was very explicit about what I needed. I came with:

Clear user stories and personas

Strong opinions about architecture (I pushed back on a cron job approach and Devin adapted to lazy materialization instead)

Specific questions when something felt off ("won't this be a performance hit?", "is the rate limiter too small?")

A willingness to let Devin research before building

Good prompting is essential. I treated Devin like a skilled engineer who just joined me — capable, but needs context and direction. When I gave vague instructions, the results were less focused. When I gave clear constraints and asked Devin to research first, the results were excellent.

This may or may not match your experience. If you tend to have clear ideas but not enough time to build them yourself, Devin can be incredibly valuable. If you're still figuring out what to build, you might need to invest more in the research/planning conversations first.

How it started

I got access through a friend (thanks Nader for the coupon!). I used it as a real test: could I actually ship something meaningful on a side project while working full-time? After a month, I renewed my subscription. Not because Devin is perfect, but because the math works: I have ideas, I have clarity on what to build, and I genuinely don't have the time blocks to build it myself. Devin fills that gap.

Who this is for

If you're in a similar situation — you know what you want to build, you have the technical judgment to review and direct, but you don't have the hours to write every line yourself — Devin is worth trying. It's not magic. It's a capable engineer that needs clear direction and works asynchronously.

The value isn't "AI writes my code." The value is: I can ship a real product as a side project without quitting my day job.

——

Cover image by Rene Böhmer on Unsplash

---

See also:

Vibe code like a PRO — the conceptual vision of Linear→background agent→PR pipeline; Devin is the real-world implementation I built with this exact pattern

How to Background Agents — practical Cursor background agent setup; Devin operates as a more autonomous version of the same concept

AI & Agent Workflows — Short Posts — collection of posts about AI-assisted development workflows

Product Backlog — AI Dev Tools — product opportunities in the AI development tools space

Graduated Trust: A Web-of-Trust Proposal for Open Source in the AI Era — the trust problem Devin's autonomous PR pipeline creates, and a social-graph-based solution; this article is a live case study of why graduated trust is needed