We spent decades writing code for machines. Now we need to express intent for them.
There’s a quiet anxiety in software development right now.
If AI can write code… where does that leave developers?
The answer is simpler and more uncomfortable than it seems.
Builders are not becoming obsolete.
They are becoming more important.
Because in a world where machines can generate code, the real bottleneck is no longer syntax.
It is clarity of intent.
AI is not replacing developers.
It is amplifying them.
A vague developer with AI produces noise.
A precise developer with AI produces systems.
The leverage has shifted but the responsibility has not.
Developers who can express intent are still in control.
But the interface has changed.
We are no longer just writing code.
We are shaping what systems should do with just pure natural language.
This shift doesn’t come out of nowhere.
My previous article on Infrastructure as Intent, I explored how systems are moving toward declared outcomes over explicit instructions.
In The Spirit of UML, I argued that abstraction is becoming essential again in the age of AI.
In this article, I propose that I ntent D riven D evelopment(IDD) is where these ideas meet in practice.
We’re Still Thinking Like Syntaxists
Even with AI tools everywhere, most developers still:
- Write code line by line
- Focus on syntax and structure
- Debug implementation details
AI becomes:
- Faster autocomplete
- Better Stack Overflow
But that misses the point.
The real shift is not AI writing code.
It is:
Developers expressing intent clearly enough that machines can realize it.
From Syntax to Semantics
We were trained to be syntaxists.
We think in functions, APIs, and control flow.
Intent Driven Development requires semanticists:
- Intent
- Constraints
- Context
- Outcomes
Code doesn’t disappear.
But it stops being the starting point.
Intent becomes the source. Code becomes the artifact.
Writing Better Prompts is Writing Better Software
In this world, prompts are not casual inputs.
They are design artifacts.
Weak:
Build a dashboard
Intent-driven:
Build a Streamlit dashboard using Snowflake TPCH data. Show revenue trends over time, allow filtering by region and customer segment, and generate natural language insights. Keep the UI minimal and ensure queries are efficient.
The difference is precision.
A Real Example: From Intent to App (Cortex + Streamlit)
Development Loop
Start with intent that clearly defines the end outcomes:
Build a Streamlit dashboard using Snowflake TPCH data.
- Show revenue trends over time
- Allow filtering by region and customer segment
- Use Cortex to generate natural language insights
- Keep the UI minimal but interactive
- Ensure queries are efficient and reusable
No boilerplate. No step-by-step instructions just clear intents.
Using tools like Cortex Code, this intent can translate into:
- Snowflake queries over TPCH tables
- Aggregations for revenue trends
- A Streamlit UI with filters and charts
- LLM-generated summaries like: “Revenue dipped in Q3 due to decline in APAC region”
You didn’t handwrite everything.
You guided the system with intent.
Where Developers Still Matter
The first version won’t be perfect.
Maybe the query is inefficient.
Maybe the chart is unclear.
Maybe the insights are generic.
You refine the intent:
- Optimize queries for large datasets
- Make insights specific to region trends
- Add anomaly detection
Each iteration improves the system without dropping to low-level code immediately.
But… How Do You Know It’s Good?
You build something like this and think:
“Looks right… but can I trust it?”
This is where most AI-driven apps fail.
Not in building but in knowing whether they’re accurate and efficient.
Adding a Evaluation Layer with TruLens
Intent Driven Development needs evaluation.
Frameworks like TruLens make this practical.
They help measure whether your system aligns with your intent:
- Context Relevance → Is the system finding the right data?
- Groundedness → Are insights tied to actual data?
- Answer Relevance → Is the system completing its goal?
- Plan Quality → Is the agent forming a plan that is optimal for the user’s goal?
- Tool Selection → Is the agent choosing the right tools for each task?
- Plan Adherence → Does the agent follow its own plan, or drift mid-execution?
- Tool Calling → Are tools being called correctly and with the right inputs?
- Logical Consistency → Does the agent maintain coherent reasoning across steps?
- Execution Efficiency → Is the agent solving the task with minimal steps, cost, and latency?
These aren’t just metrics.
They are checks on your intent and the system’s ability to complete your goals.
The New Loop
Intent Driven Development changes the workflow:
- Define intent
- Generate system
- Measure results
- Refine intent
You’re not just debugging code.
You’re debugging meaning.
Why This Matters Now
- AI can act on intent
- Systems are too complex to handcraft
- The bottleneck is idea → implementation
IDD reduces that gap.
It lets developers operate closer to the problem than the plumbing.
The Developer Shift
The next generation of developers will:
- Express constraints clearly
- Structure intent precisely
- Guide AI systems
- Measure quality continuously
The best developers won’t write the most code.
They’ll express the clearest intent and validate it.
Closing
We taught machines to understand syntax.
Now we need to lead them with intent.
AI hasn’t taken control away from developers.
It has raised the bar for what control means.
The developers who thrive in this shift won’t be the ones who write the most code.
They’ll be the ones who can:
- express intent clearly
- define constraints precisely
- And validate outcomes rigorously
Because in this new model, code is no longer the source of truth.
Intent is.
AI is powerful but it is still just an executor.
The developer remains the authority.
And like any good system, the quality of the output will always depend on the clarity of the input.
It starts with something simple.
The next intent you write.
Resources
If you want to explore Intent Driven Development hands-on, here are a few starting points.
Try the Intent Yourself
Use this prompt with Cortex Code (or a similar tool) and iterate on it:
Intent Prompt:
Build a Streamlit dashboard using Snowflake TPCH data.
Requirements:
- Show revenue trends over time
- Allow filtering by region and customer segment
- Use semantic queries over Snowflake tables
- Generate natural language insights for trends and anomalies
- Ensure all insights are grounded in actual query results
- Keep the UI minimal, fast, and interactive
Constraints:
- Optimize queries for large datasets
- Structure the code for reuse and clarity
- Return both data visualizations and textual summaries
Output:
- Streamlit app code
- Snowflake queries used
- Example insights generated from the data
Start with this, then refine the intent.
That’s the practice: improving the clarity of what you want the system to do.
👉 Check out the TruLens cheatsheet: https://github.com/Snowflake-Labs/sf-cheatsheets/blob/main/rag-evaluation-cheatsheet.md
Top comments (0)