Skyline is a product exploration of what
an IDE in the AI age might look like.
This website is a work in progress.
Vibe coding can feel fast and fun, but it falls short for production software. On the other hand, using models only for small, local tasks doesn't take full advantage of what they can really do.
Skylines is a product exploration of what better AI collaboration might look like, beyond prompts. One that gives you speed without giving up control.
The idea is simple: work with the model to design the architecture on canvas, map out data flows, and define validation rules. Once that foundation is in place, the model can take over the heavy lifting and write the code.
Every time new technology appears, people often carry over methods and practices from an older medium to a new one, only to eventually realize that the new medium requires different approaches.
This happened for example when we transitioned from radio to TV. Shows were often adapted directly from radio, maintaining the same script-driven approach. It wasn’t until later that we realized the new medium was capable of much more.
Today, the same pattern plays out with AI-driven IDEs. These tools simply extend what worked in the past by adding an AI layer, using text prompts as the sole interface between the dumb editor and the smart model.
Relying solely on prompts creates a bottleneck in collaboration bandwidth. There’s only so much precision you can pack into a single prompt, and as the scope expands, you end up introducing “vibes”—a euphemism for lack of control.
As models get smarter, the gap between what you want and what the model understands you want becomes the real bottleneck.
Skyline is about closing that gap. It explores new ways to collaborate with AI that keep you, the engineer, in control—while still letting the model handle the heavy lifting on complex tasks.
We know that in the orbit of possible solutions, (1) we want to avoid writing too much code, as it slows us down, yet (2) we also can’t rely purely on ‘vibing’ through prompts, as its high-scope, low-fidelity nature often fails to capture our intent.
This creates an interesting alignment problem, where we have to balance opposing forces: we need to explain what we want to the model (control ) without being overly verbose (fast ).
Our proposed solution involves designing software from a bird’s-eye perspective by collaborating with the model to break down the architecture into manageable, clearly defined tasks, before instructing it to write code.
To enable fast yet controlled software design, Skyline introduces an intermediate abstraction layer called symbols, positioned between the model and the code.
Unlike textual prompts, which are just raw strings until processed by the model’s smart black box, symbols are spacially anchored pieces of information that can have strong types, represent data structures, define interfaces, and connect to other symbols.
This makes them compelling building blocks, as Skyline collaborates with developers through a deliberate, top-down design process, with the symbolic architecture outlines data flows, interaction patterns, and validation checkpoints.
Once the overall architecture is clearly defined and scope reduced, the models can effortlessly translates these symbolic expressions into concrete, well-defined code.
This project is a recent endeavor, so far driven by a single person: Damian Kaleta.
Damian is both a designer and engineer, specializing in the intersection of technology and user interfaces.
He previously worked at Apple and Uber—at Apple, he contributed to the Safari and Photos apps and was part of the original Apple Watch team. At Uber, he focused primarily on the driver’s app.
He also founded a language learning company called Topics which ultimately didn’t reach product-market fit.
If you're interested in this project, feel free to reach out. These are still very early days, and I’m on the lookout for a cofounder.
For engineers building production software who want more control over software architecture when working with models.
It's a new collaboration paradigm: work with models to design software at a higher level of abstraction—architecture, data flows, and validation logic—then use models to generate the code.
Not entirely. The abstraction is only on the design side, to help you communicate more clearly and efficiently with the model. The IDE will have two modes you can switch between seamlessly: design and code. The code mode will feel like any modern IDE you're used to.
Still early days. We’re aiming to have something by the end of the year, but if you’d like to try early alpha versions, let us know!
It's a metaphor: standing on the shore, looking at a city skyline—you see the big picture, the structure, and complexity, all at once.