When I started programming in the 1990s, the world was just beginning to grapple with the transformative power of software. Back then, writing code felt like pure magic—a way to create something out of nothing. Decades later, despite exponential growth in technology, that process hasn’t fundamentally changed. Yes, we’ve gained better tools, frameworks, and languages, but the act of programming is still largely manual, requiring developers to type out logic, line by line.
And here’s the irony: the very industry building AI, automation, and tools to revolutionize other fields has itself been slow to embrace real automation. We’re still pouring hours into repetitive, tedious work. Even the rise of AI copilots has introduced its own friction—spending more time crafting the “perfect” prompts than actually solving problems.
This frustration is something I've felt throughout my career and it eventually led me into a space called Enterprise Low-Code. Here I began to see glimpses of what the future could look like. Low-code platforms promised incredible speed and productivity, slashing development time for complex applications from months to weeks. At their best, these platforms were prime examples of what could happen when we rethink programming from the ground up.
But those platforms always came with significant trade-offs. They were proprietary systems, often locking users into expensive license fees. More troublingly, they introduced a lack of control that developers found intolerable. These platforms didn’t generate clean, usable code—they stored your application in a proprietary database, compiling it into something resembling code only when needed. Developers lost the ability to directly interact with the lifeblood of their work: the source code itself.
And while the speed benefits were undeniable, low-code platforms never gained widespread adoption among developers. Why? Because programming is more than a means to an end—it’s a craft. When a platform takes away control, when it dictates how things are done, developers resist. I realized that to truly change the way we build software, we needed a different approach.
A Vision For The Future of Programming
I had an idea that low-code could be done in a better way. Not a way that replaces code, but one that augments it. Instead of taking control away from developers, it would give them more control. Instead of hiding the source code, it would make it more accessible.
Here’s the vision I had in mind for this new approach:
- Free to use: Just like the most popular IDEs, it would need to be free to gain mainstream adoption.
- Code-first, always: Developers should be able to write code as normal when they want to. No walled gardens, no lock-in.
- No cloud lock-in: No forced cloud component or proprietary database. Your code stays on your machine.
- Real-time updates: It shouldn’t work like a generator or compiler that spits out code after the fact. Changes should happen in real time.
- Language agnostic: It should be built to support any programming language
- Desktop-first: No browser-based experience. Developers work locally, on their own machines, with the speed and performance they expect.
- Keyboard-friendly: No drag-and-drop, mouse-heavy UI. Developers are fast with a keyboard, and a good low-code experience should respect that.
- Team-oriented: Development should feel more like a shared experience. Teams should be able to collaborate in real time, not in isolated ticket silos.
- Traceable requirements: The gap between requirements and implementation should be closed. Requirements should live in the codebase, traceable to the exact logic they influence.
At first, it felt like just a grand idea. It didn’t seem possible. Low-code had always come with a fundamental trade-off: speed vs. control. You could have one or the other, but not both. I spent years toying with the concept, thinking about it in the background while working full-time jobs. But then something clicked. I realized there was a way to do it that hadn’t been tried before.
Once I figured that out, there was no going back.
Taking the Leap
I left my job. No salary. No safety net. Just the belief that this idea was worth building. I had finally found a path to something I believed could change how developers work forever.
I’m now building this idea full-time. It’s called Vast Studio, and while it’s still early, it works. The concept I spent years dreaming about is now something tangible—a real platform, with real users, that’s shaping up to be everything I envisioned.
But quitting my job wasn’t the hard part. Building it is.
Here’s just a glimpse of what it takes to build a platform like this:
- Incorporation & legal setup: Setting up a business entity, dealing with contracts, and understanding legal requirements.
- Freelancers & contractors: Hiring, managing, and collaborating with freelance developers and designers to fill in skill gaps.
- Budgeting & runway: Every decision affects the burn rate. Managing finances is as important as managing features.
- Code-signing apps: If you want to distribute desktop apps for Windows and Mac, you have to go through the maze of code-signing, notarization, and app store certifications.
- Content creation & marketing: It’s not enough to build the platform. I have to write, create content, and share the vision with developers everywhere.
These challenges are tough, but they come with the territory. And, honestly, I wouldn’t have it any other way.
The Future I Want To Build
I want to create a future where developers spend less time on busy work and more time solving real problems. Where we’re not stuck fixing typos or tracking down syntax errors but thinking critically about the logic, design, and user experience of the systems we’re building.
I want teams to collaborate in real time, where a developer never has to feel isolated, grinding on a ticket alone. I want requirements to be embedded into the code itself, traceable from "idea" to "implementation" with no ambiguity.
I believe that developers should have tools that work for them—not against them. They shouldn’t have to accept trade-offs in speed, control, or transparency. That’s why I’m dedicating everything I have to Vast Studio, a low-code platform for developers, by developers.
I don’t know how long it will take, and I don’t know how big it will become. But I do know this: the future of programming will be defined by how much we’re able to eliminate the unnecessary friction in our workflows.
Vast Studio is my attempt to eliminate that friction once and for all.
Share Your Thoughts
I’d love to hear from you.
Does this vision for a new kind of low-code platform resonate with you? Do you think we’re still clinging to old paradigms that hold us back?
Drop a comment below with your thoughts, your doubts, and your ideas. I’m in the trenches building this every day, and I’d love for you to be part of the conversation.
Top comments (0)