Future

Inspiration

Future started from a simple observation: we have more powerful AI tools than ever, but turning an idea into something concrete still involves a surprising amount of friction. Users often have to jump between different tools to brainstorm, plan, organize information, generate content, and finally turn their ideas into action.

We wanted to explore what happens when these fragmented steps are brought together into one coherent experience.

Instead of building another isolated AI feature, we set out to create Future — a system that helps users move from an initial idea to a structured, actionable result through an AI-native workflow. Our goal was to make the interaction feel less like operating a collection of tools and more like collaborating with an intelligent workspace that understands what the user is trying to accomplish.

Kiroween gave us the perfect opportunity to turn that idea into a working product and, more importantly, to experiment with how AI-assisted development itself could change the way we build software.

What it does

Future is an AI-powered workspace designed to turn high-level user intent into structured actions and usable outputs.

Users can start with a simple natural-language request, and Future helps break that request into smaller steps, organize the relevant information, and guide the user through the workflow instead of returning only a one-shot AI response.

The core experience focuses on three principles:

• Intent first: users describe what they want to accomplish instead of manually configuring every step.
• Context awareness: information generated throughout the workflow remains connected so users do not have to repeatedly explain the same task.
• Actionable outputs: the system is designed to produce structured, useful results rather than stopping at conversational answers.

We also designed the interface to make complex AI workflows feel visually simple. The user sees the important decisions, current state, and resulting output without needing to understand the underlying orchestration.

How we built it

We built Future iteratively with Kiro as an important part of the development workflow.

Rather than immediately writing individual features, we first translated the product idea into explicit requirements and implementation tasks. Kiro helped us reason about the architecture, convert product requirements into development specifications, and maintain consistency while the project evolved.

We used Kiro's spec-driven workflow to break larger ideas into smaller implementation units. This was especially useful when a feature affected several parts of the application at once — UI state, data models, application logic, and error handling.

We also used Kiro throughout development to:

• explore alternative implementations before committing to an architecture;
• generate and refactor repetitive application code;
• reason about component boundaries and data flow;
• debug integration issues across different parts of the system;
• keep implementation decisions aligned with the original product requirements;
• rapidly iterate on UI details without losing consistency across the application.

The application was designed with a modular architecture so that individual capabilities can evolve independently while still participating in the same user workflow.

One of the biggest advantages of this approach was iteration speed. Instead of treating AI as a code-completion tool, we used Kiro as part of the engineering process — moving repeatedly between idea → specification → implementation → testing → refinement.

Challenges we ran into

The hardest part was not simply adding AI to an application. The real challenge was making AI behavior predictable enough to become part of a usable product.

Natural-language requests are inherently ambiguous. The same sentence can imply different goals, required information, or expected outputs. We had to think carefully about where the system should infer intent automatically and where the interface should expose an explicit decision to the user.

Another challenge was keeping the experience coherent as the project grew. AI makes it possible to prototype features extremely quickly, but fast implementation can also create inconsistent state management, duplicated logic, and unnecessary complexity. We repeatedly refactored the project so that new functionality extended the underlying system rather than becoming another isolated feature.

UI design was another important challenge. We wanted the intelligence of the system to feel powerful without making the interface complicated. That meant hiding unnecessary implementation details while still giving users enough visibility to understand what the system was doing.

Finally, working within a hackathon forced us to make aggressive scope decisions. We had many ideas that could have been added, but we prioritized building a smaller end-to-end experience that actually worked.

Accomplishments that we're proud of

We're especially proud that Future became more than a collection of AI-generated features.

We built a coherent end-to-end workflow in which user intent can move through multiple stages while preserving context and producing a usable result. Achieving that required us to think simultaneously about product design, AI interaction, software architecture, and user experience.

We're also proud of how quickly we were able to iterate using Kiro. Features that would normally require several rounds of planning, implementation, and refactoring could be explored much more rapidly while still keeping the project structured.

Most importantly, we ended the hackathon with a working product that demonstrates the central idea behind Future rather than only a conceptual prototype.

What we learned

The biggest lesson was that building an AI-native product is very different from simply adding a chatbot to an existing interface.

The most valuable part of AI is not necessarily the final generated answer. It is the ability to connect previously disconnected stages of a workflow: understanding intent, reasoning about context, proposing actions, generating artifacts, and helping the user continue from one step to the next.

We also learned that specification becomes even more important when development gets faster. AI can generate code quickly, but without clear requirements and architectural constraints, that speed can easily produce complexity instead of progress.

Using Kiro reinforced the value of spec-driven development. Having explicit requirements and implementation plans gave the AI enough structure to be genuinely useful while keeping us in control of the important engineering decisions.

The project also changed the way we think about AI-assisted software development. The most interesting future is not developers asking AI to write isolated pieces of code; it is developers and AI continuously collaborating across planning, implementation, debugging, and iteration.

What's next for Future

Future is currently a hackathon prototype, but the underlying idea can go much further.

Our next step is to make the system more adaptive and personalized so that it can understand longer-term user context rather than treating every workflow independently. We also want to expand the range of actions the system can perform and make complex multi-step workflows more reliable.

On the engineering side, we plan to improve evaluation, observability, and failure recovery so that AI-driven actions become easier to inspect and trust. We also want to continue simplifying the interface as the system becomes more capable.

Ultimately, our goal for Future is simple:

Turn AI from something users ask questions into something they can actually build, decide, and accomplish things with.

Built With

• python