The idea was simple: a web page that shows one stock, and right under it a clean options chain layout. Calls on the left, puts on the right, strike in the middle, expirations as tabs. Nothing fancy. Just the UI that makes scanning fast.

I did not want to start in Figma. I also did not want to open a repo and spend hours aligning columns, I just wanted the quickest path to a credible first screen.
So I tried Google Stitch.

What Stitch is (and why I cared)

Stitch is a Google Labs experiment (beta) that generates UI designs for web and mobile from a prompt (and it can also take visual references). It is meant to make design ideation fast, and it can produce front end code as output.

Google recently announced an update that brings Gemini 3 into Stitch, with the promise of higher quality UI generation.

That’s the pitch. My question was: does it actually help when you have a very specific layout in mind, not just “build me a dashboard”?

The prompt I gave it (high level)

I asked for an options-chain style page with:

• A header for symbol, company, price, and day change
• A table-like grid with calls on the left, puts on the right, and strike centered
• Columns like open interest, volume, bid, ask, last
• Dark mode, high contrast, clean typography
• A subtle highlight around the current strike

I kept the prompt structured and concrete. Less “make it modern,” more “center column is strike and should be visually emphasized.”

What I got back

Stitch produced a clean, readable GUI that matched the intent almost immediately.

Not perfect. Not production-ready. But it nailed the hardest part of early UI work: getting from words to a coherent layout that feels real.

That first draft is the moment where product work becomes collaborative. You can point at something and say, “this column is too noisy,” or “the strike needs more separation,” or “make the expiration tabs sticky.”

You are no longer debating abstractions.

Why this felt different from a normal “generate UI” tool

Two things stood out.

1) It respected structure.
The center strike column matters. The symmetry matters. The scan pattern matters. Stitch kept that mental model intact instead of turning it into a generic dashboard.

2) It reduced the blank-canvas tax.
Even if you can build UI quickly, the first version still costs attention. Stitch made that cost close to zero, which is exactly what I want for a weekend experiment.

The real workflow win: Stitch as a front end starting point

The interesting part is what happens next.

Once you have a solid UI draft, you can hand it off in multiple directions:

• Design-first: refine the layout and components in your normal design flow (and keep iterating from something real).
• Engineering-first: treat the output as scaffolding and wire it to real data.
• AI builder handoff: use the UI as input for tools that turn descriptions and prototypes into functional apps and websites.

This is where tools like Lovable or Base44 can be useful. They position themselves as “build apps and websites with AI” and “build fully functional apps from your words.”

In other words, Stitch can give you a strong UI direction, then another tool can help translate that into a working web app if that is your goal.

The takeaway (for product people and AI engineers)

This experiment reinforced a simple idea: UI ideation is becoming cheap.

Not cheap in quality. Cheap in time.

When the cost of a first draft collapses, you iterate more. You explore more shapes of the product. You spend your energy on the decisions that matter, not on the first alignment pass.

Stitch did not build my app. It did something more useful for a weekend: it got me to a credible starting screen fast, and that is often the difference between “nice idea” and “I might actually ship this.”

LLM apps move fast. Prompts evolve. Models change. Parameters get tuned. Tools come and go.

If every tweak requires a code change, a rebuild, and a redeploy, we will burn time on plumbing instead of learning what actually works.

That’s where Config-Driven Development (CDD) shines.

What Is Config-Driven Development?

Config-Driven Development is the practice of externalizing behavior and policy into configuration files (JSON, YAML, etc.), so you can adjust how the system behaves without touching application code.

It’s already common in MS architecture: routing rules, feature flags, retry policies, API gateways, toggles, and environment-based settings.

The important boundary:

• Config should control behavior and policy
• Code should own core business logic

Think of config as the “control plane” for how your app runs, not a replacement for real programming.

Why CDD and LLMs Fit So Well

LLM apps have an unusually high rate of change:

• The system prompt is a product surface, not a constant
• We may want to switch between models (quality, cost, latency)
• We constantly tune temperature, max tokens, tool usage, safety rules
• We often need routing (simple requests to a cheaper model, complex ones to a stronger model)

CDD turns these changes into data updates, not engineering work.

A Minimal JSON Config Pattern (That Actually Scales)

Here’s a simple config that covers the essentials:

{
  "models": {
    "default": "gpt-5",
    "cheap": "gpt-4o-mini"
  },
  "prompts": {
    "system": "You are a helpful assistant that explains tech concepts simply.",
    "user_template": "Explain {topic} in one short paragraph."
  },
  "parameters": {
    "temperature": 0.7,
    "max_output_tokens": 180
  },
  "routing": {
    "max_topic_words_for_cheap_model": 3
  },
  "governance": {
    "store_responses": false,
    "config_version": "1.0.0"
  }
}

A few practical notes:

• Do not store secrets (API keys) in config
• Keep configs small at first.
• Treat config changes like code changes: review, test, version, and roll back.

Python Integration Example (Using OpenAI Responses API)

This is a small example showing how config drives runtime behavior.

import json
from openai import OpenAI

def is_simple_topic(topic: str, max_words: int) -> bool:
    return len(topic.strip().split()) <= max_words

with open("ai_config.json", "r", encoding="utf-8") as f:
    config = json.load(f)

topic = "config driven development"

client = OpenAI()

# Route to a cheaper model for very short / simple topics
use_cheap = is_simple_topic(topic, config["routing"]["max_topic_words_for_cheap_model"])
model = config["models"]["cheap"] if use_cheap else config["models"]["default"]

response = client.responses.create(
    model=model,
    instructions=config["prompts"]["system"],
    input=config["prompts"]["user_template"].format(topic=topic),
    temperature=config["parameters"]["temperature"],
    max_output_tokens=config["parameters"]["max_output_tokens"],
    store=config["governance"]["store_responses"]
)

print(response.output_text)

Now you can:

• Change prompts without touching code
• Adjust parameters safely
• Update routing rules
• Switch models per environment (dev vs prod)

All without a redeploy cycle for every single experiment.

Let the LLM Generate the Config

LLMs can help produce configs too, especially for:

• Translating product requirements into structured settings
• Generating prompt variants
• Producing JSON/YAML skeletons for new workflows

The key is governance:

• Validate the output against a schema
• Run tests (including prompt tests)
• Review changes like you would review code
• Ship via staged rollout

Without those guardrails, “LLM-generated config” becomes “random behavior in production.”

Spotlight: NVIDIA NeMo Agent Toolkit (NAT)

If you’re building agentic workflows, NVIDIA NeMo Agent Toolkit (NAT)
https://developer.nvidia.com/nemo-agent-toolkit (Currently v1.3)
is worth a look. I took DeepLearning AI Course, here is my summary:

What makes it relevant here is that it leans into config-driven workflows:

• YAML configuration builder for agent workflows
• Swap LLMs, tools, and frameworks with minimal code changes
• Built-in support for observability like logging, tracing, and metrics

This is the kind of ecosystem where CDD becomes not just convenient, but essential.

Real Benefits You Actually Feel

When config drives LLM behavior, teams usually get:

• Faster iteration: experiment without rebuild and redeploy loops
• Reproducibility: config versions map to known behaviors
• Collaboration: product, data, and engineering can align on the same artifact
• Governance: approvals, audit trail, and rollback are straightforward
• Cost control: routing and model switching become easy knobs
• Observability: it’s easier to attach metadata to each run and trace behavior

Pitfalls And How to Avoid Them

CDD is powerful, but it can go wrong.

Over-configuring everything
✅ Start with a small set of system prompt, model, temperature, max tokens, routing.

Breaking prod with a “small tweak”
✅ Add schema validation + CI checks, and ship config via staged rollout.

Config drift across environments
✅ Separate “base config” from “environment overrides” (dev/stage/prod).

Unreviewed LLM-generated configs
✅ Treat generated configs as drafts until validated and tested.

Conclusion

LLM apps are not static software. They’re closer to living systems.

Config-Driven Development gives you a clean way to evolve those systems without turning every experiment into a deployment project.

If you’re building anything beyond a demo, consider making prompts, models, routing, and parameters first-class configuration.

It’s one of the simplest changes you can make that pays off again and again

References

• NVIDIA NeMo Agent Toolkit: https://developer.nvidia.com/nemo-agent-toolkit
• DeepLearning AI: https://learn.deeplearning.ai/

Why I Tried Zed 🧪

I recently tested Google Antigravity, AWS Kiro.
I wanted to see how well the new IDEs and agents work, how fast they feel, and what new abilities they offer.
Zed was next on my list. I spent yesterday and today trying it with real tasks, writing code, letting it write code, and comparing the experience with the others.

My Setup 🖥️

I do not have a Zed license, but it connected to my paid Claude account without any problem.
I worked in JavaScript.

First Impressions ⚙️

The first reaction was clear. Zed is fast.
It feels smooth, the UI responds instantly, and switching between files has no delay.
Rust gives it a real performance boost.

Working With Zed🤖

Zed offers chat, inline suggestions and agent support.
Most of the time it worked well. I used JavaScript and Claude Code behind the scenes and it felt perfect.

There was one issue. When I asked a question while the agent was working, kindly interrupted him, it got confused and stopped working on the original request for the newer one. I had to tell it to continue from where it stopped. It was not a big problem, but it showed that the agent flow is not as mature as in Cursor or Antigravity yet.

Performance and Speed 🚀

This is where Zed stands out.
Startup is fast
Navigation is fast
Editing is fast
Nothing felt heavy
The memory usage was also lower than other IDEs I tried.

Extensions and Ecosystem 🔌

There are extensions, and I tried a few, but I did not explore deeply.
The feeling is that the ecosystem is growing, It is already good enough to work.

Comparison With Other IDEs 🆚

I use several IDEs often.
Antigravity is polished, Cursor has strong features, and Claude Code understands code very well.

Zed was faster than all of them in my experience. it also allow you to follow what he is doing during the process, It gives an instant feeling of speed and responsiveness.

Will I Keep Using It 👍

Yes, I will keep using it next to Antigravity and Claude Code.
It gives me fast results and helps me move quickly when I test or build something new.

The Game Changer You Haven’t Heard Of Yet

After spending a significant number of hours experimenting with Google’s new Antigravity IDE, I can say this with confidence:

👉 This is a game-changer.

Let me explain.

Right now, it’s fair to say that the platform isn’t fully “baked” yet. It has rough edges, quirks, and early-stage limitations. But the potential is staggering. Once this tool reaches the stability level of more mature platforms, it will pose a serious challenge to competitors like Claude Code, Cursor, and others in the AI-assisted development space.

So, what exactly makes Antigravity different?

What Makes Antigravity IDE Different From Other AI Coding Tools

Beyond the Wrapper

At first glance, Antigravity feels familiar. Like Cursor and many modern IDEs, it’s built on the foundation of Visual Studio Code. The wrapper, editor, and basic UX are instantly recognizable.

No need to re-learn how to open files.

But then, Google adds something new, and it changes everything.

Hands-On Experience: Building a Web App With Gemini

The Agent Manager: Coding With a Partner, Not Just a Copilot

Antigravity introduces a feature called the Agent Manager.

It’s currently in Preview, but the potential is immense.

The Agent Manager allows you to define an Agent that writes programs or executes concepts based entirely on your prompt. This isn’t just autocomplete. It feels closer to having another developer on the team.

Google integrates this with a browser extension, creating a seamless link to Chrome. And that’s where things start to get wild.

My Workflow: Example in Action

Here’s a test I ran:

I asked an agent to build a web application of options.

Knowing Gemini (the model powering this) thrives on examples, I provided one. But before the agent started coding, I instructed:

“List exactly what you are going to do.”

The agent created a plan. I approved it.

And then the magic kicked in.

Why Live Visual Feedback Is a Breakthrough

Live Visual Feedback While Coding

As the agent worked, it opened Chrome.

I watched the application being built and rendered in real time.

Down to the smallest details.

There is also an Inbox, where the agent updates you on progress, asks questions, and requests approvals. It’s amazing.

But the real breakthrough is the interactive feedback loop:

While the agent is coding and the UI is live in the browser, I can mark areas on the screen and leave comments: “This button isn’t right, replace it with a dropdown”, “Highlight this area and add a title.”, you can do the same on the real code in real time.

The agent receives this feedback while it works.

I have never seen this in any other tool. It feels like doing a design review of a product that is still in progress, except the developer is an AI agent.

Parallel AI Agents: Multitasking Like a Team

Multitasking With Multiple Agents

Here’s where things get even more interesting:

While one agent was building the app, I launched another agent (using the plus sign, you can add many).

That second agent was tasked with preparing a marketing campaign for the very same product.

Yes, you can run multiple agents in the same Workspace.

You can also run agents in other Workspaces in parallel. And there’s a dedicated Playground area where you can test ideas before committing them to a real project.

This starts to look like distributed work, except everything happens on your machine, instantly.

Limitations and Early-Stage Bugs

The Verdict: Not Quite There, But Coming Fast

My impression is simple: 👉 This is a monumental shift.

When this reaches maturity, it will change the industry. Entire roles may disappear, and new ones will emerge. The way we build software is about to transform. But we’re not there yet.

Antigravity still has early-stage issues:
Sometimes it doesn’t do exactly what you tell it to do, especially compared to Claude Code for the same prompt.
Occasionally it starts working before approval, even when told to wait.

These are normal bugs, but once this stabilizes?

It’s going to be insane.

Final Thoughts

Antigravity feels like a glimpse of the future

Real-time coding | Live UI feedback | Parallel agents | Browser integration | Context across Workspaces

It’s not just an IDE.

It’s a collaborative system where AI builds, reviews, and evolves software with you.

We’re entering a new era.

💻 The Setup: Surprisingly Smooth

The installation process was refreshingly straightforward. Here’s what caught my attention:

• Node.js dependency — Nothing unexpected, but worth noting for those planning to try it
• Windows compatibility — I decided to challenge it by testing on Windows instead of the typical Linux environment
• Quick installation — From download to running took just minutes
• Seamless authentication — Connecting with Google Gemini Pro was hassle-free

🧪 Putting It to the Test

Rather than diving into complex projects, I opted for a methodical approach:

My Testing Strategy:

• Created simple, non-sophisticated solutions
• Focused on evaluating speed and responsiveness
• Assessed the user interface and overall experience
• Monitored for any obvious limitations or quirks

The goal wasn’t to build the next big thing, but to understand how this tool feels in practice.

📊 First Impressions: The Good and The Areas for Growth

✅ What’s Working Well

Speed & Responsiveness: The CLI feels snappy and handles basic requests without noticeable lag.

User Experience: The interface is clean and intuitive — you can start being productive almost immediately.

Direction: Google is clearly onto something here. The foundation feels solid for future development.

⚠️ Room for Improvement

Compared to Claude Code: Let’s be honest — it has some catching up to do. Claude Code currently offers a more polished experience.

Hallucination Issues: I encountered some instances where the tool generated incorrect or inconsistent responses. This isn’t uncommon for early AI tools, but it’s worth noting.

Temperature Control: Currently, there’s no apparent way to adjust the model’s creativity/randomness settings. Having this control would be valuable for different types of tasks.

🎯 The Bottom Line

My recommendation? If you’re someone who enjoys testing new AI tools (like I am), give it a try. Just set appropriate expectations — you’re getting a glimpse into the future.

Quick Takes on What I’m Using

• Google AI Studio 🧠 (aistudio.google.com)
• Windsurf 🌬️ (windsurf.com): Feels like a real coding partner, understanding your whole project.
• Loveable ❤️ (lovable.dev): Need a web app fast? Describe it, and Loveable builds a starting point. Super quick!
• Cursor ✨ (cursor.sh or cursor.com): Think VS Code, but with a super-smart AI built-in. You can “chat” with your code to get things done.

Void 🌌

Void (https://voideditor.com/ or check their GitHub: github.com/voideditor/void). Open-source & free🤯

A powerful alternative to pricey options, letting you use AI across your whole project. What’s awesome is you get more control, can even use your own AI models, and it’s built on VS Code, so it feels familiar.

P.S. Quick heads-up: I used Gemini to help me rewrite and shorten this post 😉

What AI coding tools are you exploring? Tried any of these, Drop your thoughts and finds in the comments!

Let’s keep learning and building together! #AI #Coding #TechTools #GoogleAI #Windsurf #Loveable #CursorIDE #VoidAI #FreeSoftware #OpenSource #Developer

In a world overflowing with productivity tools and subscriptions, it’s easy to get overwhelmed — or worse, sign up for dozens of things and forget what you’re even paying for.

As a hands-on product manager deeply involved in both strategy and execution, I’ve tested countless tools over the years. But these are the ones I actually pay for and use daily — tools that deliver real value in my work as a T-PDM in 2025.

🧠 1. OpenAI (ChatGPT Plus & API)

I’ve been a paying user since nearly day one. The value OpenAI brings to my workflow — whether it’s writing, ideation, or advanced technical tasks — has only grown. With the release of the o3 reasoning model, it’s become even more powerful and intuitive.

I also use the OpenAI API for more custom scenarios, including automating workflows and writing code — yes, even some low-level MCP code. If you’re building anything technical or writing-heavy, this is a must-have.

🧩 2. Claude

Claude is my second brain — especially when I need more nuanced, long-context support. While it’s not my default for every task, it complements OpenAI perfectly. I use Claude for brainstorming product narratives, refining strategy docs, and exploring edge ideas with fewer guardrails.

🐦 3. X (formerly Twitter)

Yes, I still pay for X. And not for the blue checkmark — but for access to longer posts, editing tools, and better visibility. X is where I keep a pulse on product trends, AI breakthroughs, and founder-style thinking. Following the right voices here gives me daily insights that no internal Slack channel ever will.

🔍 4. LinkedIn (Premium — Following)

I use LinkedIn Premium for one simple reason: to follow top thinkers and product leaders closely. It helps me cut through noise and zero in on quality content and professional movements. Sometimes, the difference between spotting a trend early or late is just being tuned in.

👨‍💻 5. Cursor AI

As a product manager who still codes, Cursor AI has become my go-to dev environment. It’s built with AI-first development in mind and makes writing, debugging, and collaborating on code seamless. It’s especially helpful when I need to move fast and iterate on technical ideas without always relying on my dev team.

📚 Bonus: Learning Subscriptions I Still Use

Even as a seasoned PM, I never stop learning. I rotate between:

• Coursera & DeepLearning.AI — for more structured ML/AI deep dives
• Pluralsight & Udemy — for upskilling in architecture, devops, and cloud
• YouTube Premium — because ad-free learning (and relaxing) is underrated

💡 Final Thoughts

Every tool here has earned its place. I’m ruthless about cutting out noise, and what remains are tools that sharpen my thinking, support my workflow, and help me stay ahead of the curve.

Would I recommend all of them to every PM? Not necessarily. But if you’re a hands-on builder who blends product thinking with tech, this stack might be exactly what you need.

The return was natural for me, given my familiarity with most of the teams, technology, and groups. This position is essentially a full circle for me after having previously held roles in development areas as well as architect positions in both Amdocs and startup companies.

The main challenge, as I anticipated, is the ability to translate requirements from clients and those stemming from the product itself into valuable features for the demanding clients and in general.

So far, I’ve been in the role for six months, taking responsibility for several areas. It’s very interesting and promotes both business thinking and the technological aspect.

I prepared a list of cool sites on this subject, including GAN, GPT-3, GPT, GPT-$, Open AI, and all the latest news.

If you comment, I may add more.

On top of all — ChatGPT, OpenAI, Transformers library, Jasper AI, DALL-E 2

1. Wordtune, AI21 Labs
2. Midjourney- Independent research lab, BlueWillow — Like Midjourney
3. Anyword — Copywriting AI
4. Debuild- Create your web apps with AI
5. Co-Pilot — AI pair programmer, using OpenAI Codex
6. Tabnine- AI for software developers
7. AIVatar- Create a unique AI-generated avatar of yourself
8. Hourone AI- Text into Video
9. Podcast AI- Entirely generated by AI
10. Artssy — Unique AI images
11. Spellbook- Review and suggest language for your contracts
12. Coqui- AI Voices
13. Looka- Design your own beautiful brand/logos
14. Yurts AI
15. Adflow — Create ads in seconds
16. AIVA — AI composing emotional soundtrack music
17. Rytr — AI writing assistant for high-quality content
18. Harmonai- Make music using AI
19. Resemble AI- Voice AI toolkit
20. Images AI
21. Deep AI- AI to enhance your creativity
22. Starryai- Generate art by describing
23. AI Dungeon
24. Diagram- Generative design tools
25. Lumalabs AI — Create 3D using text
26. Scenario gg- AI-generated game assets
27. Spatial — Create and share 3D experiences.

I tried to list some of the most interesting ones, but there are always more to add.

GPT-4 still has no release date.

1. Fall in Love with the Problem, Not the Solution: A Handbook for Entrepreneurs Hardcover — January 17, 2023 https://a.co/d/bg135LP
2. Competing Against Time: How Time-Based Competition is Reshaping Global Markets — https://a.co/d/d1tFSjU

Finished reading

1. Secrets of Sand Hill Road: Venture Capital and How to Get It Hardcover — June 4, 2019 https://a.co/d/9CY3nHq

The plan is to read books that interest me but are also recommended by Steve Jobs, Jeff Bezos, and Bill Gates, Tim Cook and more.