Stop Using AI Like a Code Vending Machine

The Six Modes of Software Composition and How to Use Them

Chances are if you’re reading this, you already know something about Software Composition.

Maybe you’ve even blasted ideas into Claude Artifacts, ChatGPT Canvas, V0.dev, Lovable.dev, Bolt.new or if you’re off the waitlist, GitHub Spark. If you’ve only tapped into these chat-oriented programming tools to churn out quick React apps, you’re missing the bigger picture.

You’ve heard about Co-Pilot, Cursor, and Codieum.

Your mettle grows as you graduate from locked-down PaaS environments to your go-to AI IDE.

So what’s next?

How do you start, how do you progress, and in what modes does Software Composition truly excel?

The Six Modes of Software Composition

At SpecStory,

Greg Ceccarelli

, myself and the team software compose daily — and not just for raw implementation.

Below is our opinionated breakdown of six distinct modes, how they connect, and how you should think while operating in each.

Mode 1 — Idea Refinement

Core Challenge: Picture yourself as an Enterprise PM hearing, “We need AI!” Your real job is to ask, “What problem are we solving?” Idea Refinement in the context of software composing means turning lofty, easy-to-dismiss dreams into practical, buildable proposals.

The Mission: Turn “we need AI” into “we need to classify support tickets into three priority levels with 90% accuracy”. For those classified at low levels, route them to an AI support agent that is able to assist the customer or user.

Software Composing Refinement

• Use Claude/GPT or even Cursor (with access to the underlying models) to expand vague requirements into detailed user stories

• Generate edge cases and potential failure modes for each part of the feature

• Take that technical objective and use AI to generate scenario analyses that tie back into your high level business objectives

Action (Today): Pick your most ambiguous requirement and use an AI editor to spin out five different interpretations. Narrow it down to three testable outcomes.

Mode 2 — Prototyping

Core Challenge: Building to learn isn’t the same as building to last. Most get stuck perfecting their prototypes. Don’t. Your job is to prove or disprove your riskiest assumptions as quickly as possible—like, within hours.

The Mission: Hack together a working prototype in a single day that nails the core value proposition. Use synthetic data for realism (even if everything’s duct-taped behind the scenes).

Software Composing Refinement

• Let AI generate realistic synthetic data with a compelling narrative.

• Build quick UIs that zero in on the critical path; ignore edge cases.

• Create fake APIs returning pristine data for your happy path.

• Have AI produce diverse test scenarios to stress your assumptions.

Action (Today): Take your riskiest feature. Build a throwaway prototype with AI-generated test data. Show it to a stakeholder tomorrow.

Mode 3 — Disposable apps

Core Challenge: When Greg talks about "disposable apps," he’s highlighting that sometimes code serves best by dying young. These apps go further than prototypes—they’re actually deployed and used but skip all the usual production guardrails. They prove paths to production while staying intentionally short-lived.

The Mission: Ship usable software without production overhead. Forget lint rules, build optimizations, or CI/CD pipelines. Deploy fast to test environments. Learn from real usage, then toss it when you’re done.

Software Composing Refinement

• Break normal rules on purpose—document what standards you’re ignoring and why.

• Deploy manually—no CI/CD pipeline required.

• Replace code review with pair programming.

• Embrace messiness; chase learning instead of cleanliness.

• Have AI generate multiple architectural variants at speed.

• Document insights about the problem domain, not just the code.

Action (Today): Pick a feature bogged down in analysis paralysis. Build and deploy a throwaway version that ignores your usual best practices. Get it in front of users in under a week. Use AI to move fast and note everything you learn.

Mode 4 - Production Code

Core Challenge: Production code meets real users, real scale, and real consequences. You can (and should) use AI here—just don’t be naïve. “Trust but verify” is the name of the game.

The Mission: Survive contact with reality while staying maintainable.

Software Composing Refinement

• Have AI scan your code for potential scaling issues.

• Generate comprehensive test scenarios based on actual production patterns.

• Ask AI to review error handling and propose more robust edge cases.

• Build monitoring and observability from the jump.

Action (Today): Take your most successful prototype and list all the ways it’d break in production. Use AI to uncover additional failure points. Then do the real work:

1. Read every block of AI-generated code. If you don’t understand it, ask. AI often improves when challenged.

2. Write comments. If you can’t explain it, you don’t truly get it.

3. Think through security, performance, and maintainability.

4. Validate package versions. AI can get them wrong due to cutoff dates—Google is your friend.

Mode 5 - Operations & Deployment

Core Challenge: Understanding how to get from local dev to cloud config is crucial. The challenge isn’t just shipping code to production but fully grasping the operational tapestry. Your advantage? AI can funnel the collective knowledge of ops teams worldwide right into your workflow.

The Mission: Bridge development and operations. Make deployment and maintenance as core to your project as the code itself. And remember, coding-focused AI might not always have the best or newest answers for operational questions—sometimes ChatGPT in browsing mode is more relevant.

Software Composing Refinement

• Let AI interpret complicated cloud documentation into plain-English steps.

• Generate Infrastructure-as-Code templates that align with your real needs.

• Build dashboards with actual system health metrics, not just uptime checks.

• Explain not just what you did, but why you did it this way.

Action (Today): Identify one manual step in your deployment process. Use AI in web-browsing mode to find a modern way to automate it. Whip up a proof of concept. Document the how and why.

Mode 6 - Troubleshoot and Debug

Core Challenge: Debugging in software composition demands a partnership between human insight and AI guidance. Plain error messages aren’t enough. Your mission is to build systems that leave behind helpful breadcrumbs—logs, metrics, and context—so debugging becomes a guided investigation, not a blindfolded search.

The Mission: Transform debugging from reactive firefighting into proactive system understanding. Leave a clear trail for anyone—human or AI—who might need to explore the system’s past behavior. Make logs that tell stories, not just record problems.

Software Composing Refinement

• Build Rich Context:

  • Capture screenshots, environment details, and recent changes

  • Track system changes over time with semantic versioning

  • Document environment differences early.

• Strategic Logging:

  • Log with breadcrumbs that AI (and humans) can follow.

  • Show state transitions with before/after context.

  • Capture relevant business context in technical logs

• Semantic Logging Patterns:

  • Replace "Error in user authentication" with "Failed to verify JWT token for user {id} with error {specific_error}"

  • Add business context: "Premium feature {feature} access denied for free tier user {id}"

  • Include actionable data: "Rate limit exceeded: current rate {current} exceeds limit {limit} for API key {key}"

  • Log successful operations too: "Successfully processed {count} records in batch {id} taking {duration} ms"

Action (Today): Take your most frequent error and rewrite its logging to deliver a complete narrative:

1. Add rich context about when and where it occurs

2. Include relevant business and technical details

3. Create clear correlation between related events

4. Use AI to generate comprehensive test cases that would trigger this error

5. Document the pattern in your team's debugging playbook

Making the Modes Work

If you’re still treating AI like a code vending machine, you’re missing the point. Every mode in software composition calls for a different relationship with your AI tools. Sometimes it’s about speedy exploration; other times, it’s methodical verification and deep understanding.

The magic isn’t in the prompt alone—it’s knowing which mode you’re in and adjusting your approach accordingly. AI IDEs and LLMs aren’t a single hammer. They’re a versatile toolkit you adapt to the job:

• In Idea Refinement: AI is your sparring partner, challenging assumptions and generating fresh angles.

• In Prototyping: AI gives you rapid generation and synthetic data on demand.

• In Disposable Apps: Let AI churn out multiple approaches fast—no polishing needed.

• In Production: Collaborate with AI for thorough analysis and to spot tricky edge cases.

• In Operations: Lean on AI (especially with web-browsing) for up-to-date operational wisdom.

• In Debugging: Work alongside AI to craft and interpret rich, semantic debugging logs.

Next time you open your IDE, ask yourself: Which mode am I in?

And how should that change the way I work with AI?

Your future self will thank you for the clarity.