I Built My Own AI Agent Over the Weekend. Here Are My Notes.

What started as a Slack bot became a weekend rabbit hole I'm pretty glad I fell down.

The original idea was simple: build something that would ping me each morning with a summary of my emails and whatever tasks I had open in Notion. Useful, low-stakes, probably a two-hour project. Instead, it became a personal AI agent. I named it Dezi. Short for design.

Here's everything I learned.

Key Takeaways

• Building a personal AI agent is more accessible than it looks. Vercel's AI SDK handles the heavy lifting. The real work is in the design thinking.
• Dezi collects my tasks, drafts emails, manages my calendar, and delivers daily briefs from a single Notion-backed dashboard.
• The most underserved surface in AI products right now is the micro-interaction layer: thinking states, tool call feedback, progress communication.
• Focused, single-purpose agents build more user trust than generalist ones.

Why Does a Designer Keep Circling Back to This?

There's an honest answer and a polished one. The honest one: I've had this itch for a long time. I work with AI startups. I design agent features for clients. I use Claude through the terminal basically all day. And yet I had never actually built one of these things from scratch. That felt like a gap I needed to close. If you're curious about what patterns I keep seeing across AI products, I wrote about what makes most AI companions forgettable.

The more considered answer is that the design surface area of an AI agent genuinely fascinates me. An agent isn't just a utility. It operates more like a mascot. It guides the user, creates or removes anxiety depending on how it's designed, and communicates through micro-interactions that most teams don't have the bandwidth to think through properly. That's a real design problem.

I'd been listening to The Designer Tom's podcast, and a few episodes in particular made this feel less like a rabbit hole and more like territory worth exploring seriously. Sometimes you just need to hear that someone else is thinking about the same problems.

Meet Dezi

The simplest way to describe it: Dezi is a personal work dashboard with an AI brain. It runs on Vercel's AI SDK with my Notion account as the database. All my client projects, admin tasks, and ongoing work already live in Notion. Dezi pulls them together into a single view I can actually use without clicking through six tabs and three sub-pages.

Before this, I had these beautiful, intricate Notion dashboards that I'd build on a Sunday, feel good about, and abandon by Wednesday because they required too much maintenance. Dezi sidesteps that problem entirely. One login. One screen. A clear picture of where things stand.

Beyond task collection, Dezi can draft emails, check my calendar, schedule things, and run daily cron jobs that surface what I need before I've opened a browser tab. The morning brief I originally wanted? It's there. It just comes with a lot more context than I planned for when I started.

Gratifying is the right word for finishing a working version. Not fully done. Done enough. I've written tickets to myself for the gaps. But the core of what I needed is working, and that's the bar that matters right now.

Building It Was Simpler Than I Expected

Here's the thing that actually surprised me: integrating an agent into the dashboard wasn't particularly hard. Vercel's AI SDK abstracts a lot of the complexity. If you have enough technical literacy to navigate a build process, you can get something working faster than you think.

That said, working and good are different bars entirely.

The functionality came together faster than expected. The design side revealed gaps almost immediately. And the gaps weren't where I thought they'd be.

What I noticed is that Dezi felt rough not in the places where it got something wrong, but in the places where I didn't know what it was doing. The thinking states. The tool call feedback. The moments where the agent is processing something and the interface is just waiting. That's where confidence erodes. Not in the errors, but in the silence.

There's something important in that for anyone designing agent experiences.

The Design Surfaces Nobody's Working On

This is where things get a bit nerdy. Bear with me.

Building Dezi made visible something I'd suspected but couldn't fully articulate: every single interaction surface in an agent experience requires design attention. Every tool call. Every loading state. Every moment the agent is thinking. Every confirmation that says here's what I did and why.

You can see traces of this thinking in Claude Code, in Gemini. There's clearly been intention put into some of those interactions. But there's room to go much deeper, and most teams aren't getting there because they're moving too fast.

Here's the part I keep coming back to: those micro-interactions aren't cosmetic. They're load-bearing. A progress indicator that communicates clearly, a thinking state that doesn't feel like a black box, a confirmation step that reads like a conversation rather than a modal -- these are the things that separate an agent people trust from one they abandon after a week. I wrote about this pattern in depth in why 90% of AI companions get forgotten.

Smaller companies, ones that aren't racing to ship 50 features a quarter, have a genuine opportunity here. That's where a designer like me can actually move the needle.

Agents Need a Soul (Literally, a soul.md)

One of the stranger things I learned while building this: agents need a document that gives them personality.

It's often called a soul.md. A markdown file that defines the agent's tone, its point of view, how it communicates with the person it works for. Alongside that, you give the agent context about yourself: your preferences, your working style, the things you care about. These files are what make the difference between an agent that feels mechanical and one that actually feels like it knows you.

From a product design perspective, this is a fascinating unsolved problem.

If you're building for consumers, how do you capture this from someone who has never opened a markdown file? How do you give someone's agent a personality without it feeling like filling out a form? How do you make that setup process feel like meeting someone rather than configuring a device?

The soul.md is a developer's workaround for a problem that deserves a designer's solution. Nobody has cracked it yet.

Why Focused Agents Beat Generalist Ones

One conviction that solidified quickly: Dezi needs to stay scoped.

Right now, it's focused entirely on my work: client projects, admin tasks, scheduling. That focus is intentional. Every time I tried to add something outside that scope during the build, the useful parts got diluted. When it does too many things, it does most of them okay and none of them well.

I think we're heading toward a world where most people have multiple agents, each dedicated to a narrow band of closely related tasks. An agent for groceries. An agent for email. An agent for scheduling. Whether those are eventually managed by a single orchestrating agent or by the person themselves is still an open question. But a focused agent reduces errors and builds user confidence in a way that a do-everything agent just doesn't.

This is actually an old design principle showing up somewhere new: scope reduction is a feature. The more clearly defined the job, the more trustworthy the tool. The same logic applies to the broader shift toward personal design systems: focused tools, owned by one person, built for a specific purpose.

The Grandmother Test

Building Dezi was not easy. There was a lot of back-and-forth. There were dead ends. Things that worked in development and broke in practice. I made it through because I had enough technical context to keep going.

My grandmother could not do this.

That's a problem, and I think it's the most interesting gap in the current market. We're starting to see it addressed with products like Lindy, and I'm sure there are others. But I don't think we've hit the version that genuinely democratizes this. The one where anyone, not just designers and developers with time on a weekend, can pull a purpose-built agent off a shelf, configure it in plain language, and have it running by lunch.

That marketplace is what I keep imagining. Not an app store organized by category, but one organized by outcomes. An agent that handles your inbox. An agent that tracks your health habits. An agent that manages your freelance contracts. Pre-built, reviewed by real people, set up in a conversation rather than a settings menu. That's the version of this that changes something. And whoever designs that onboarding experience is going to get it very right or very wrong.

Experiments Are How Designers Stay Relevant

As a freelancer, it's genuinely easy to go prehistoric. You get deep in a project. You ship the work. You move to the next one. Six months pass and you're still running the same patterns and the same thinking. Tunnel vision creeps in quietly.

Experiments like building Dezi are how I push back on that. Not because I'll necessarily turn it into a product, although I haven't ruled it out. The value is in the process. Building this pushed me into territory that's directly relevant to client work I'm doing right now. The thinking is current. The problems are real. I came out of this weekend with a longer list of design questions than I started with, which is exactly the outcome I needed.

For other designers and freelancers: find the thing that's been pulling at you. Build a rough version. The practice of making something is different from studying something, and that difference compounds over time.

What's Next for Dezi

Dezi isn't done. It's done enough to be useful, which is a different thing.

There are parts I want to design properly: better thinking state visualizations, a cleaner task surface, a morning brief that feels actually designed rather than just output. The soul.md needs more thought. And I want to work through what onboarding would look like for someone who didn't build this, because that's the design problem I actually care about most.

There's also the bigger question I keep sitting with: is this just mine, or is there a version of this that someone else needs?

For now, it's mine. That's enough to keep building.

---

Frequently Asked Questions

What did you use to build Dezi?

Dezi runs on Vercel's AI SDK with my Notion account as the primary database. I added the agent as an integration into a personal dashboard I was already building. The SDK handles the model connections and tool use. Notion handles everything related to task storage and retrieval.

Why is it called Dezi?

Short for design. It felt right for an agent built specifically for my design practice. Naming it also made it feel more like a collaborator than a script, which honestly matters more than it probably should.

Do you think everyone will have a personal AI agent eventually?

Yes, in some form. Whether people build their own, buy through a marketplace, or get one bundled into tools they already use, personal agents are coming. The question is what the designed experience looks like when that happens at scale for non-technical users.

What's the biggest design opportunity in AI agents right now?

The interaction surfaces that happen while the agent is working: thinking states, tool call feedback, progress communication. These are underdeveloped across almost every product I've seen. Small, focused teams have a real opportunity here before the larger players catch up.

Would you recommend building your own agent?

If you have the technical curiosity and a real problem to solve, absolutely. Start narrow. Keep the scope tight. You'll learn things about how agents actually work that you can't get from just reading about them. And you'll probably come out with more design questions than you started with, which is the point.