What's Next? Building Truly Autonomous Development

Everyone's talking about AI coding tools, but here's the thing: autonomous development means a lot more than writing code, just like autonomous driving is a lot more than cruise control and lane assist.

We've been watching tools like Cursor and Claude get insanely good, week after week. But as coding gets faster, we hit a wall. The bottleneck just shifts to everything else: planning, design, coordination, review, release. All the messy human stuff that makes software actually ship.

So we asked ourselves a simple question: What's next?

The Real Challenge Isn't Code

Even if current LLMs are as good as they'll ever get (though I doubt it), here's the thing: they're already good enough. Good enough to code, good enough to reason, good enough to solve problems.

The real magic isn't the AI itself—it's the software we build using AI that's going to change everything.

Right now, thousands of developers are building this next wave of software and facing similar challenges: an LLM can generate great code in seconds, but then you spend hours on everything else. That frustration is driving an entire generation of builders to create software that goes way beyond code generation.

We're not just automating individual tasks—we're building systems that can plan, coordinate, execute, and learn from their own work. Software that can manage entire workflows, make decisions, and iterate on approach.

Everyone's focused on the AI wave, but what comes next—because of AI—is what will really transform how we work. We're part of that movement, obsessing over the problem because we can see it happening in real-time.

We're not trying to make AI better. We're trying to build software that makes everything else better, using AI as the engine. And we're definitely not the only ones racing toward this future.

Our "What's Next?" Approach

The setup is almost embarrassingly simple: a dev environment in a VM with Cursor, Claude 4.0, GitLab, Playwright, and our MCP tools talking to the Telos platform.

We built seven simple tools that let Cursor get instructions from our AI agent (we call it Kappa) and provide updates on progress and work done:

1. GetNextTask - Kappa tells Cursor exactly what to do next, with ticket numbers and context
2. GetTicketDetails - Full context and implementation instructions, pre-prepared by Kappa
3. GetGitBranchForTicket - No more "which branch am I on?" confusion
4. AskQuestion - When stuck, ask for help (flagged for humans if needed)
5. MarkTicketAsBlocked - Escalate to humans when truly stuck
6. UpdateActionItem - Track progress through checklists and tasks
7. AddComment - Document everything as it happens

The workflow? One simple prompt: "Get the next task and execute the instructions."

Is It Really Autonomous?

No. Let's be honest here.

It's sophisticated automation, not true autonomy. But that's exactly the point. We're not trying to replicate human judgment, we're trying to eliminate the friction between decisions and execution.

Hard-Won Lessons

Get it off your laptop. If you want autonomous, it needs its own accounts, email, access controls. We run on a zero-trust model: the AI gets exactly what it needs, nothing more.

It needs management. When you're "vibe-coding," you're steering. When it's autonomous, someone needs to plan the next move based on progress and goals. That's where the real intelligence lives.

Make rollbacks trivial. AIs make assumptions. Sometimes bad ones. Rolling back code is easy in GitLab, but we also needed to roll back tasks, documentation, context. Once rolled back, correct the bad assumptions and hit go again.

The Philosophy Behind the Code

This "What's Next?" approach has changed how we work entirely. We used to set quarterly goals, but things move too fast now. Instead, we constantly ask: What's the next problem to solve? What's our biggest pain point? How do we make 1% progress toward our vision this week?

We're applying the same thinking to AI: keep building context about the big picture, then let it take the next logical step.

What This Means for Business

Here's where it gets interesting. We believe every business should have purpose-built software now. Not in five years. Now.

AI is exciting, but what comes next - because of AI - will really change everything. We work with relentless business owners who know what they want and need software that can keep up with them.

That's why we built Telos as a fully managed service to build and run this software. The software is yours. The platform manages the work. The AI handles the execution.

What's Next?

We're still early. This system handles small, well-defined tasks beautifully. But we're constantly pushing: What's the next capability to unlock? What's the next bottleneck to eliminate?

The goal isn't to replace developers. It's to let us focus on the problems that actually matter while the AI handles the mechanical execution of getting there.

So what's next for your business? Because if you're not asking that question every week, you're probably falling behind.

‍

Want to see what purpose-built software could do for your business? We'd love to show you what's possible when you combine relentless focus with autonomous execution. Contact us

‍