And I'm still processing what it means for software development And I'm still processing what it means for software development Here's my journey in three acts: Act 1: Traditional coding took me 3-4 months for a simple functional app. Act 2: AI coding tools? Same app in under 4 weeks. Game-changer. Act 3: Imagine with Claude? Minutes. And the app built itself as I used it. Let me explain what just happened. The Moment It Clicked I wanted to build a Historical Photo Detective upload old photos, get instant analysis of the era, fashion, architecture, cultural context. Standard prototype stuff. My exact prompt was: My exact prompt was: "Build a Historical Photo Detective - Upload old photos and get context about the era, fashion, architecture visible" "Build a Historical Photo Detective - Upload old photos and get context about the era, fashion, architecture visible" That's it. One sentence. Then something unexpected happened: My initial prompt created a landing page with an upload button. When I clicked it, Claude wrote the upload code right then and showed me a file picker. After I uploaded a photo, the system figured out the next step processing and implemented it on the fly. right then Here's the key insight: The app didn't exist when I started. It materialized through my interactions. Here's the key insight: Each action I took triggered specific code generation. No follow-up prompts. No hand-holding. Just natural usage. Testing with the Mona Lisa I downloaded a picture of the Mona Lisa to test the system. Uploaded it. The application immediately recognized it and gave me: What it was (the Mona Lisa)
Who painted it (Leonardo da Vinci)
Historical period (Renaissance)
Artistic techniques used
Cultural significance What it was (the Mona Lisa) Who painted it (Leonardo da Vinci) Historical period (Renaissance) Artistic techniques used Cultural significance I didn't program any recognition system. I didn't train a model. I didn't build lookup databases. I just described what I wanted, used the app naturally, and it worked. This is an alpha release from Anthropic for select Max subscribers. And it's showing us something fundamentally new I'm Calling It: Just-In-Time App Generation Traditional development works like this: Requirements → Design → Code → Test → Deploy → Use Requirements → Design → Code → Test → Deploy → Use AI-assisted development shortened it to: Describe → Generate Code → Use Describe → Generate Code → Use But JIT Generation flips the entire model: JIT Generation flips the entire model: Use → Code Generates → Use More → More Code Generates Use → Code Generates → Use More → More Code Generates The application writes itself incrementally, action by action, based on what you actually do not what you predicted you'd need. What Makes This Different from Everything Else I've used Claude Code, Cursor, Replit, Windsurf. They're all excellent AI coding tools. But this is fundamentally different. Traditional AI Coding Tools: You write prompts constantly
You guide: "add this feature," "fix that bug," "create this component"
You hand-hold the entire process
Front-end knowledge is essential
It's prompt engineering from start to finish You write prompts constantly You guide: "add this feature," "fix that bug," "create this component" You hand-hold the entire process Front-end knowledge is essential It's prompt engineering from start to finish Imagine with Claude: You describe the app once
You just use it naturally
It builds itself based on your navigation
Minimal technical knowledge needed
No prompting after the initial description You describe the app once You just use it naturally It builds itself based on your navigation Minimal technical knowledge needed No prompting after the initial description The difference? Prompt-driven versus navigation-driven development. Prompt-driven versus navigation-driven development. With traditional tools, you're still a developer giving instructions. With JIT Generation, you're a user, and the system infers what code it needs from how you interact. The Technical Reality Current limitation: 100,000 token context window 100,000 token context window For an alpha release, that's reasonable. It handles: Focused prototypes
Single-feature demos
MVP validation
Smaller applications Focused prototypes Single-feature demos MVP validation Smaller applications Not enough for enterprise-scale apps with dozens of features. But that's not the point right now. Who Should Care About This Product Managers You can finally visualize how the app works without waiting for design or dev cycles. Describe the concept, get a working prototype, show stakeholders, gather feedback on real interactions all in the same meeting. Timeline shift: Idea to functional demo in minutes instead of weeks. UX/UI Designers Skip the entire handoff process. Design in your head, describe it, use the working prototype, see what feels wrong, adjust immediately. No more "move that button 2px left" tickets. Just real-time iteration. Founders Without Technical Co-founders The validation barrier just disappeared. Describe your idea, test it, share it, gather feedback all before end of day. You don't need to hire a developer to validate your concept anymore. Current Limitations (Being Realistic) Restricted Alpha Access Restricted Alpha Access Only available to select Max subscribers. Not widely accessible yet. No Persistence No Persistence Refresh your browser? Everything's gone. Great for ideation sessions, not for ongoing development. Prototyping Focus Prototyping Focus Imagine with Claude creates interactive prototypes with UI interfaces, frontend logic, and can even access hardware  features like device cameras for mobile simulations. But it's NOT designed for production apps requiring: Backend infrastructure
Database integration
API architectures
Enterprise scalability
Multi-service coordination Backend infrastructure Database integration API architectures Enterprise scalability Multi-service coordination This is a prototyping engine, not a full-stack replacement. Context Limits Context Limits 100K tokens works for prototypes, not complex applications. Production versions will likely expand this significantly. Why This Matters When prototyping becomes this effortless: Validation cycles collapse from weeks to hours
Product managers become builders, not just documenters
Experimentation cost approaches zero
The gap between imagination and reality disappears Validation cycles collapse from weeks to hours Product managers become builders, not just documenters Experimentation cost approaches zero The gap between imagination and reality disappears We're witnessing a shift from "describe what you want the code to do" to "use the app and it figures out what code it needs." That's profound. What Happens When JIT Becomes Production-Ready? Right now, this is alpha. Experimental. Prototype-focused. But when JIT Generation reaches production maturity with full-stack capabilities: Apps get built without traditional coding workflows
Complete applications generate (frontend, backend, databases, APIs)
The developer role transforms fundamentally
Other companies will adopt similar approaches (competition accelerates innovation) Apps get built without traditional coding workflows Complete applications generate (frontend, backend, databases, APIs) The developer role transforms fundamentally Other companies will adopt similar approaches (competition accelerates innovation) I'm particularly interested in seeing full-stack applications built this way systems that generate entire architectures: backend services, database schemas, API endpoints, authentication systems, the works. full-stack applications That's when the real revolution begins. Try It Yourself If you have alpha access: Go to claude.ai/imagine
Think of a simple tool (respect the 100K token limit)
Describe it once, then just use it stop prompting
Let your navigation drive the development
Test with real data (try the Mona Lisa!)
Share with someone for immediate feedback Go to claude.ai/imagine Think of a simple tool (respect the 100K token limit) Describe it once, then just use it stop prompting Let your navigation drive the development Test with real data (try the Mona Lisa!) Share with someone for immediate feedback Even though it's temporary and imperfect, you'll understand the shift happening here. The Bottom Line I've gone from months to weeks to minutes. But this isn't about speed. It's about a fundamental shift in how software gets created. Apps aren't something you build anymore. They're something you discover through use. Apps aren't something you build anymore. They're something you discover through use. Imagine with Claude is alpha release with real constraints restricted access, no persistence, token limits, prototype-only focus. But it's showing us a future where: Building and using are the same activity
Prompting gets replaced by navigation
Technical barriers lower significantly
Ideation happens at the speed of thought Building and using are the same activity Prompting gets replaced by navigation Technical barriers lower significantly Ideation happens at the speed of thought This is Just-In-Time App Generation. I'm still processing what it means. And I'm eagerly waiting to see full-stack versions of this concept. That's when things get really interesting. Have you tried Imagine with Claude? What did you build? How does navigation-driven development feel compared to traditional prompting? Have you tried Imagine with Claude? What did you build? How does navigation-driven development feel compared to traditional prompting? Share your experiences in the comments I want to hear what others are discovering.

This story contains new, firsthand information uncovered by the writer.

Front

Moment

From Months to Minutes: I Discovered Just-In-Time App Generation with "Imagine with Claude"

About Author

Comments

TOPICS

THIS ARTICLE WAS FEATURED IN

Related Stories

Untitled Story

How I Built Google's "Adaptive Timeout" Feature 9 Years Before Google Did

Stop Hallucinations at the Source: Hybrid RAG That Checks Itself

The New Open AI Agent Builder is Not an Agent Builder At All

How I Built a Production-Grade AI Prompt That Writes Executive Summaries in 30 Minutes

The Noonification: How Often Do NFTs Pass The Howey Test? (1/13/2023)

How I Built Google's "Adaptive Timeout" Feature 9 Years Before Google Did

Stop Hallucinations at the Source: Hybrid RAG That Checks Itself

The New Open AI Agent Builder is Not an Agent Builder At All

How I Built a Production-Grade AI Prompt That Writes Executive Summaries in 30 Minutes

The Noonification: How Often Do NFTs Pass The Howey Test? (1/13/2023)

Light-Mode

Classic

Newspaper

Dark-Mode

Neon Noir

Minty

HN StartUps