Form factors for your new AI coworkers — Craig Wattrus, Flatfile

I think we've all noticed tools like V0 getting pretty good at generative UI and creating good-looking things, as well as Claude Code being able to let us run things more complicated locally and build on those things. So I think the thing that comes out of this is designers, product people, and engineers all building together.

And I'm really excited about that, because I've never loved the divides between these things. So this really lets us get rid of, in my mind, get rid of mockups, get rid of the click-through prototypes, and all the hand-wringing about whether the thing that we're building is worth the engineering effort.

So as we go into this, it's time for us to jump in and feel the material that we're working with and see what emerges. So I'll give you a super quick overview of Flatfile's AI stack. This is not an official diagram, but it's how I see it.

We migrate data big; if you need to move a lot of data between systems frequently, you use our developer platform. And since we're a developer platform, LLMs are good at writing code, makes it the perfect place for a lot of AI.

At the bottom here, we have our customers' Flatfile applications that they deploy to our infrastructure. Then there's this real-time context, which is the data and the validation outcomes. So what are the errors and warnings and things that are in that data, that dirty data?

And then our AI agents, the tools they have, and the jobs that they can run. And then what gets shown to users. So I see it as four buckets here. There's more. There's invisible, so it's kind of like the ghost in the machine, almost called that ghost.

Ambient, so it's kind of happening in this space, but you're not directly working with it. Inline, so it's actually in your work, in your workflow. And then conversational, the ones that we're, I guess, all arguing about. I think that's what I learned being here at this conference.

Here's an example of invisible. So when you start, if you sign up for Flatfile, we go in the background, we take your email address, we find the company you work for, we look it up. And in the background, the AI agents are writing a Flatfile application, so they're writing code.

And they're sending you up a demo that is perfect for your use case. So if you come in from an HR company, you're going to get an HR demo. And while that's running, you don't need to know that AI is working on it.

So that, I'd say, is like it's working in the background. Here's something working more ambiently. It's a very initial take on this, but you can see there's an agent analyzing the data in the background. This is a tool I actually I lead this team for AI transformation.

And you can see the little sparkles pop up on the columns when it finds opportunities to fix it. So that's ambient. This is inline, so you're busy working in the data, and the AI is able you're able to use the AI directly in line here to fix the data.

These agents are writing code that then gets run on this data set. So you could have a million rows and 50 columns or whatever you want, and that code will run really fast, which is pretty cool. And then finally, the conversational ones we're all used to.

So this is build mode. It's the no-code, low-code, agentic system that writes Flatfile apps now. So before, you would probably have to have had an engineer at the company building these applications. Now it can all be built up.

So that's pretty cool. And that's kind of the general surfaces I think about. I listened to Amanda Askell from Anthropic talking to Lex Friedman about building Claude's character. And in that moment, I realized I'd been doing something a little silly.

I'd been giving engineers feedback on our agents, like, oh, it shouldn't start saying this, and it shouldn't use these words, and why should it do this? And I realized I was doing it like I would do design copy,right?

I was in my normal instinct. And when I heard her talk, I realized I needed to go from controlling to being a character coach and actually building out the nature that I wanted. So this is a V0. I hope, have most of you used V0 from Vercel before?

Yeah. So this is a V0, I built one of my early ones, and it was I called it a chat tuner. It doesn't look like much, but that wasn't the focus. But I could essentially put our orchestrators, so the system prompt for our AI orchestrator for build mode, in here.

And then I can modify it. I can say, what is it like if I tell Claude to be more friendly versus more balanced versus more concise? What does more cautious mean to this model? And the point of me showing this is just to say, like, the design of the final thing is always a tempting thing to design to.

But now we can actually go and build tools to help us to design that. And this brings me to, like, I have like three themes. The first theme, which is feeling the material. I'm a woodworker, so you'll have to forgive the analogies to physical material.

But if you're going to design something with a physical material, you have to feel it,right? You have to, what are the properties of it? And you need to understand it. And so I feel like before with design, we were kind of looking at everything through, like, layers,right?

Mockups and prototypes and kind of trying to see what was going to work and what wasn't. What we need to do now is go feel the material, feel how these models work. My new north star is, like, creating an environment for these LLMs to shine,right?

What's this form factor that can help them nail their assignment, stay aligned, and grow as the models get better,right? That's my new goal. We're basically, anything we do with an LLM, I feel like we're putting it in a box.

And that's you also hear people say that LLMs are, like, interns. Like, oh, it's an intern with a PhD. And so I try to think now, if you're putting an intern with a PhD in a box, like, it better be a good box.

And so we need to put effort in. This was a conversation we were having about what tools does this coworker, this new form factor, this new model, like, what tools do we give it when it shows up for work?

And I got fixated on this idea of cursors. I was like, oh, what happens if it just had a mouse or a trackpad? I'm a trackpad person, so that's probably controversial. But essentially, what happens if we gave the AI those tools?

And so I created this V0 and moved it into cursor. And I was like, well, I work in design tools a lot, so I don't migrate a lot of data. So this is the best place for me to feel this,right?

To feel this material. So I created a canvas. And I could give it orders and be like, hey. And honestly, I was very enthusiastic about this for, like, a few seconds. It felt like I was touching the AGI a little bit.

But I also very quickly started feeling like I was putting a Formula One driver in a Prius. It just, it felt like I was constraining it and controlling it. It could only move one thing at a time. But so learning from that was something like this was also a V0 that I used Claude Code on eventually.

And this is a new product that we're working on, which brings, like, all the stuff we've learned about migrating data to consumers to let them work on their data. But you can see that AI is operating in this space.

And it's got presence. And so it's able to read multiple files while writing into another one. It's not like me, who can only focus on one thing at a time. Even though I think I can focus on more, it's not true.

And so this is us moving from determinism to inference and figuring out what this material feels like. And so that's feeling the material,right? Like, working with the model, getting it into your space, understanding how it feels to work alongside it, what's it capable of.

And then the form factors that we're putting on them, actually, you can now go build it and play with it and feel it. The next material analogy I have, which is finding the grain. Once you've got the characteristics of the material, you understand it.

Usually, the piece of material that you're building with and you're creating with might have its own characteristics. And so as we're creating these form factors, finding the grain is about feeling it out. Where is it smooth and rough?

Where is it weak? Where is it strong? And we'll have to remain humble here, because things are going to change and are changing so quickly that whatever we build is going to most likely need to be rebuilt. This was an example of that build mode agent.

I asked it to do one thing, which was enable the auto map plugin. So this just automatically maps data from the source data to the target data. And I get a wall of text. And it's not bad, because this went and it saved me probably a week of work.

I didn't have to have a product manager write a PRD, send it to an engineer, get it in the roadmap, get the engineer to write it, QA. This was all just done,right? All that code was written. But the noise gets in the way.

And so this was a V0 of kind of rethinking the tool UX. What could it be like? And so the way I thought about this was, if you're designing for a if you're going to a coworker and you're going to do something complicated for them and you want to communicate, you think, OK, I'm going to choose my words carefully.

I'm going to communicate visually. I'm going to stop and check whether it'sright. And so I wanted this to feel similar. And so you can see here, split personal details. It's visually telling you what it's doing. It's saying, hey, is thisright?

Then it's saying, I'm aligned. I took a snapshot. You can roll back. I'm holding you accountable. You approved this. And then telling you what you can do next. We also wanted it to be able to express itself. So if something went wrong, kind of shaking its head and a little bit of frustration, which is probably what the user is feeling too when something goes wrong.

And then finally, it can back off when it gets something wrong and sort of say, OK, I'm handing control back over to you. And that's a lot more that feels a lot better. And it felt like we had found the grain and found theright place to put this material with this.

And so what's really cool about this one is that as we're implementing it, we've realized that it can you can fit in other places. So not just in conversational flow, it can fit in line. And this is going to be in our kind of, like, inline transform functionality really soon.

So I think, like, as we find a new technology and work with it, we run the risk of just automating the tedious things. And I was so excited about those previous two talks, because there was kind of, like, some emergence in there,right?

Like something interesting that we weren't able to do before. And I'm most excited about those things. Like, what emerges from playing? We stopped playing for a few years when we kind of got the internet and we were, like, really excited.

And CSS3 came out and then, like, HTML5. We were playing a lot. Now I feel like we're all playing again. And so that's really exciting for me. This is an example of me playing. I created this V0, and I we've been in search of this characteristic of an agent that feels forward-leaning.

And what I mean by that is it's an agent that's curious and it's excitable, but it likes getting shit done. And it's very focused. So not going crazy,right? Like, we've all seen the LLMs kind of go too far when you give it a task, and that doesn't feel good.

So here I dropped a JSON file and a CSV file. And the agent decided you know what would be good to do is combine those two things, because the data looked pretty similar. And so here we can see it's combined the file, the two files into one.

That's a good thing that it did. I didn't have to ask it to do that. It picked up on it. And then after that, it wrote a report. So it told us what it was doing. It said, hey, I found some duplicates.

This is probably what you need to do next. And so it built up context. And I was actually just trying to play with Claude 4 here and feel the material and kind of see how it would be. But I realized I'd kind of come across this nature that we were after.

It made some suggestions and generated a slide deck, which I asked it for. So within just dropping two files, it's done something emergent. And now we're baking this into our new product called Obvious, which is coming soon. Another one was we had this idea of giving our agents a knowledge base.

So all the customer calls we'd had with them were all recorded and transcribed, like most of ours are. And we had documentation from the customer. And so we put it into a knowledge base. And then when we analyzed all of this customer data, we surfaced up suggestions based off that.

I was fully expecting better suggestions. I was fully expecting more suggestions. Got those. But then here, the agent decided, I can't fix this, but I know how to fix it. And so I'm going to tell you how to fix it.

And so it suggests here that the user actually goes to HR and gets them to generate the missing employee IDs. And what emerged here was something I wasn't expecting. Maybe you look at this and say that makes a lot of obvious sense.

But to me, I wasn't expecting it to be able to help the human to go and do the job where it couldn't. So that was really exciting. I don't think I would have been able to get to that without playing and being curious.

And then the last thing I want to talk a little bit about is eyes on the future. And we all have our eyes on the future, because how can you not? There's always something new now with models. So I like to think about it as, like, what's your Pelican on a bicycle?

And one of my Pelican on a bicycles is auto-complete. I'm super excited about this. Probably a bad idea, actually, to use an LLM for this. But I'm like, I want to make an auto-complete that is backed by an LLM.

And so this one has 100 suggestions for fixing some data. And it's kind of like a bake-off between these two things. I'm yet to find a model that is both very fast and very good at this problem. But this is a benchmark or something that I've created just for myself to be able to feel the materials that we're getting.

And so I think about that for my design practice now. Like, what are the things I care about? And can I, like, design into the future and start to think about the form factors I want and then build an application that can actually test that?

So yeah, that's all I have for you today. I'm very excited to see all the new form factors that we build with our new tools. Thank you.