skip to content
Navid Mesbah
فا
← Back

How AI Changed the Way Charsook Builds

/ 12 min read

The Shape of a Company Is Changing

When we started Charsook, scope was limited by headcount. Over more than fifteen years we have delivered more than a hundred projects for clients, ranging from spatial computing to molecule design, and every one of them was bounded by how many skilled people we could put on it. If a client wanted something ambitious, the first question was always: who do we have, and who do we need to hire?

Hiring shaped everything. It determined which projects we could accept, how fast we could deliver, how much we charged, and how much risk we could take. A studio of a certain size could do a certain amount of work, and no amount of cleverness could change that very much.

Today the constraint is different. A small team, working with many AI agents, can take on things that would once have needed a department. Not because the agents are geniuses, but because a huge amount of software work turned out to be well-specified execution. Once the thinking is done clearly, the doing can be delegated.

That changes how you build a company. I’m still learning how, and I want to share some of what I’ve learned so far, including the parts that didn’t work.

What an AI-Native Company Actually Looks Like

People sometimes imagine an AI-native company as one person and a thousand agents, all running autonomously while the founder sips tea. That’s not what it looks like, at least not for us.

It looks more like a small group of people, each of whom acts as something between an architect, a director, and an editor. Each person owns areas of the product and works with agents to build, test, and maintain those areas. The people spend their days deciding, specifying, reviewing, and talking to users. The agents spend their days implementing, testing, refactoring, and documenting.

The ratio of thinking to typing has flipped. In a traditional software team, most people spend most of their time producing code. In our team, most people spend most of their time producing decisions, and code follows from them.

This sounds efficient, and it often is. It’s also more demanding than people expect. Every person has to be good at the hard parts of their job, because the easy parts are no longer there to fill the day.

What Got Easier

Breadth. One person can now touch the editor, the backend, the evals, the infrastructure, and the documentation in the same week without becoming a bottleneck in each. In a traditional team, that kind of breadth usually meant shallow work everywhere. With agents handling implementation, a person with good judgment can work broadly and still produce solid results.

This has changed who we look for. Specialists are still valuable, but people who can think clearly across several domains are much more valuable than before.

Prototyping. We can try three versions of an idea instead of arguing about one. When someone proposes a new interaction for Charsook Editor, we no longer have to debate it abstractly in a meeting. We can build two or three rough versions in a day and look at them. Arguments about hypotheticals turn into comparisons of real things, and real things are much easier to judge.

I’ve noticed this makes the team less political. When ideas can be tested cheaply, nobody needs to win arguments by persuasion or seniority. The prototype wins or loses on its own.

The long tail. Migrations, tests, internal tools, cleanup, documentation, accessibility fixes, small performance improvements. Every software team has a backlog of work that is valuable but never urgent, so it never gets done. In our team, much of that work now gets done, because an agent can handle it in the background while people focus on what matters most.

The cumulative effect is significant. A codebase where the long tail is regularly addressed stays healthier and easier to change, which makes everything else faster.

Learning new domains. When we needed to understand a new area, say audio processing or a particular file format, agents could help us explore, prototype, and test much faster than reading documentation alone. This doesn’t replace deep understanding, but it shortens the path to it.

What Didn’t Get Easier

Deciding what to build. Agents multiply output, including the output of bad decisions. A wrong direction now gets built very quickly and very thoroughly. In the old world, a bad idea often died during implementation because it was too expensive to finish. In the new world, it gets finished, polished, and shipped before anyone realizes it was a bad idea.

This makes product judgment more important than ever. We’ve had to become much more disciplined about validating ideas before building them seriously: talking to users first, prototyping cheaply, and being honest about evidence.

Quality. More code means more surface for bugs. Agents write code faster than humans can deeply review it, and while their code is often good, it’s not always good, and its failures can be subtle.

We had to get much more serious about verification: strong types, meaningful tests, evals for fuzzy behavior, careful review of critical paths, and, for a few core pieces, formal proofs. Moving fast without that is just accumulating risk faster. I’ve come to think of verification infrastructure as the real foundation of an AI-native company. Agents are the engine; verification is the brakes and steering. A fast engine without brakes is not a fast car; it’s a crash.

Taste and coherence. A product built by many agents can drift into feeling like many products. Each agent, given a task, makes reasonable local decisions. But reasonable local decisions don’t add up to a coherent whole. Buttons start to look slightly different in different parts of the app. Terminology drifts. Interaction patterns diverge.

Someone has to hold the whole thing in their head and say “no, this doesn’t belong.” That’s a human job, and it doesn’t scale easily. We’ve built tools to help, including design critics that check consistency, but the final responsibility for coherence is human.

Talking to users. No agent can replace sitting with someone while they use your product and watching where they hesitate. The small pauses, the confused expressions, the workarounds people invent. These are the most valuable signals a product team can get, and they come only from human attention.

If anything, this matters more now. When building is cheap, the risk is building the wrong thing beautifully. Users are the only cure.

Communication. A small team still needs to communicate well. Actually, it needs to communicate better, because each person is responsible for more. When one person’s decisions are amplified by many agents, misalignment between two people produces much larger inconsistencies than before.

The Roles That Matter Now

In an AI-native company, the valuable people are the ones who can do four things well.

Frame problems clearly. Turning a vague user need into a well-defined problem is the starting point for everything. A poorly framed problem leads to well-built wrong solutions.

Specify precisely. Agents do what you say, so you have to say what you mean. Good specification is a skill, and most people haven’t practiced it, because human colleagues were forgiving about vagueness.

Judge results honestly. When an agent delivers something, someone has to decide if it’s good. This requires domain knowledge, taste, and the willingness to say “this isn’t right” even when it’s close.

Say no. Agents make it easy to say yes to everything. Every feature request can be built. Every idea can be prototyped. The discipline to say no, to keep the product focused, is rarer and more valuable than ever.

Those were always valuable skills. Now they’re the main skills.

I think of my own role as product architect and director of agents. I spend less time producing and more time deciding and checking. It’s a different kind of tiring. Writing code tires your focus; directing tires your judgment. By the end of a day of decisions, I’m often more exhausted than I used to be after a day of coding, even though I typed far less.

Our Biggest Mistake, and How AI Rescued Us

I want to be honest about what didn’t work, because the AI-native story is often told too neatly.

Our biggest mistake, for most of Charsook’s history, was over-engineering and not moving fast enough. We loved elegant systems. We designed general architectures for problems we didn’t have yet. We debated abstractions for weeks before a single user had touched the product. We built infrastructure for scale before we knew whether anyone wanted what we were scaling. Every decision felt responsible at the time. Together, they made us slow.

The cost of being slow is not only lost time. It’s lost feedback. While we were polishing, the world kept moving, and by the time our carefully built thing met real users, we often learned that some of our most careful work had been aimed at the wrong problem.

AI rescued us from this habit. Not because agents are reckless, but because they changed the cost of trying. When a working prototype takes an afternoon, it becomes very hard to justify three weeks of architectural debate. So we stopped debating and started trying. We ship small versions, put them in front of people, watch what happens, and learn. Code became something we can throw away without grief. Our instinct for structure still matters, but now we apply it after we know what is worth structuring, not before.

I think this is the general greatness of AI, and it’s for everyone, not only for companies like ours. It lowers the cost of trying. For a long time, experimentation was a luxury: you needed money, a team, and time to test an idea properly. Now a small team, a teacher, a student, an artist, or a single founder in a place with limited resources can try ten ideas instead of betting everything on one. More people get to learn from reality instead of guessing.

Speed brought its own smaller lessons. Agents need real context, so we invest in clear specifications and examples instead of vague tasks. And we write the key tests and evals ourselves, before implementation, so they encode our understanding, not the agent’s. Moving fast is only a gift when you can also tell quickly whether you’re moving in the right direction.

Hiring in an AI-Native World

Hiring has changed for us too.

We care less about how fast someone can write code and more about how clearly they think. In interviews, we ask people to frame problems, write specifications, and critique solutions. We look for people who notice what’s missing, who ask good questions, and who can explain why something is good or bad.

We also look for people with deep fundamentals in something. Directing agents in a domain you don’t understand is like directing actors in a language you don’t speak. You can’t tell when they’re getting it wrong. Deep knowledge, whether in mathematics, design, systems, or a particular industry, is what makes judgment possible.

And we look for people who are comfortable with a role that’s still being defined. Nobody has decades of experience as an agent director. Everyone is learning. People who enjoy that uncertainty do much better than those who need a clear, stable job description.

What I’d Tell a New Founder

If you’re starting an AI-native company now, here’s what I’d suggest.

Start with verification, not generation. Before you ask agents to build anything, decide how you’ll know if it’s good. Write tests, evals, and acceptance criteria first. This feels slow at the beginning and saves enormous time later.

Don’t over-engineer. Ship the small version first, learn from real people, and add structure once you know what deserves it. This was our most expensive lesson.

Keep the team small longer than feels comfortable. Every new person adds communication overhead, and in an AI-native company, communication is what holds the product together. Hire when judgment is the bottleneck, not when output is.

Hire for judgment. Look for people who think clearly, specify precisely, and evaluate honestly. Speed of typing matters very little now.

Stay close to the craft. You can’t direct agents well on work you don’t understand. The fundamentals I learned the slow way, in electrical engineering, mathematics, coaching, and design, are exactly what make me useful now. Don’t let agents become a reason to stop learning; let them free you to learn deeper things.

Protect coherence. Assign clear ownership of the product’s overall experience. Someone has to care about the whole, not just the parts.

Talk to users constantly. The cheaper building becomes, the more important it is to build the right thing.

The Bigger Picture

I think we’re at the beginning of a large change in how companies are built. For a century, organizations grew by adding people. Scale meant headcount. The largest companies were the ones with the most employees.

That link is weakening. Small teams with many agents can build things that once required large organizations. This could be wonderful: more people able to build ambitious things, more experiments, more diversity in who creates products and for whom. It could also be disruptive: fewer jobs of certain kinds, more concentration of capability in the hands of those who know how to direct machines.

I don’t know exactly how it will unfold. But I know that the companies that do well will be the ones that understand what humans are still uniquely good at, judgment, taste, care, understanding people, and build their organizations around those strengths rather than trying to compete with machines at what machines do best.

That’s what we’re trying to do at Charsook. We haven’t figured it all out. But every month, the small team gets a little better at being small, and the agents get a little better at being helpful, and the product gets a little closer to what we imagined.