There’s been quite a bit of hype around the use of AI for vibe coding applications. Add in the use of a Ralph loop and we’re getting close to being able to automatically generate entire applications. But how much of this is hype and how much is reality. In this post I’ll walk through using a simple Ralph loop with the latest Uno Platform AI tooling to build an application from just a simple specification. I let it run overnight whilst I slept, so we’ll see what it produced and where we should go next.

So, here’s a quick overview of my setup:

• Running on Windows with VSCode
• Using a devcontainer setup under WSL to make sure Claude can’t go rogue on my PC
• I created the initial Uno Platform application using “dotnet new unoapp -preset recommended” to create my application using the latest Uno Platform guidance (Material, MVUX, Navigation etc)
• I’m using Claude Code
• I’ve added both Uno Platform MCP servers
• Validated that both Uno Platform MCPs are connected and have tools loaded

IMPORTANT: In order to get a good outcome it’s very important that the Uno Platform App MCP is connected and is reporting tools (there should be 11 at the time of writing). If the tools don’t load after 30 seconds (default timeout), it’s likely to be a result of one or two reasons:

• Not Authenticated with Uno Platform account. If you’re in a container/WSL you can launch the Studio app by running (substitute {version} with the version that you have. If none, run dotnet restore on your Uno Platform app):
  dotnet ~/.nuget/packages/uno.settings.devserver/{version}/tools/manager/Uno.Settings.dll
• Not able to resolve Solution or Project that references Uno Platform. Change to the directory that has the Solution (.sln) file before running Claude.

Whilst I’m using Claude in this example, the above setup, including the instructions for validating MCPs, applies to other AI agent CLIs (eg Codex).

Application Specification

Before I got started building the application I launched an interactive session with Claude and in Plan mode proceeded to describe the set of features for my application. I started with a brief description of the app:

“Help me determine the specifications for a financial tracking and planning application”

Through structured Q&A, , the following was established:

• Audience: Personal/household use
• Platforms: Web (WASM), Desktop (Win/Mac/Linux), Mobile (iOS/Android)
• Tech stack: Uno Platform (.NET/C#), SQLite, MVUX, Uno Material, LiveCharts2
• Data entry: Manual only (no bank sync/import)
• Storage: Local only (no cloud)
• Auth: Local account — username + BCrypt password + recovery phrase + optional PIN

8 features were defined (F1–F8):

All 8 features were broken down into 42 issues on GitHub with full acceptance criteria and linked to their parent epics.

Basic Ralph

Sometimes when I hear Ralph discussed it ends up being overly complex, for example requiring the use of plugins. This is one of those topics that you can make as complex as you want. For me, it’s just a basic execution loop that works through a predefined list of tasks until completed.

With this in mind, the first thing to do was to create an ordered list of my GitHub issues for my Ralph loop to work through. Again, I used Claude for this with the following prompt:

Retrieve all open github issues. Sort them in the order that they should be completed (ignore epics) and write them to a file openissues.md

This created an openissues.md file with issues listed as follows:

Now onto the Ralph loop itself. This is just a bash script (Credit to Dan Vega in his video The Ralph Loop Explained: Automate AI Coding Tasks in Java where I borrowed the structure of this script from).

#!/bin/bash

SLEEP_BETWEEN=10
LOG_DIR="logs"

mkdir -p "$LOG_DIR"

for ((i=1; i<=$1; i++)); do
  echo ""
  echo "****************************************"
  echo "Iteration $i of $1"
  echo "****************************************"

  outfile="$LOG_DIR/iteration_${i}.log"

  claude --dangerously-skip-permissions -p "@openissues.md @progress.txt \
0. Make sure uno and unoapp MCP are connected and that unoapp MCP has 11 tools available. After 30s if the unoapp MCP tools are not available, do not update GitHub issue and exit immediately. \
1. Read progress.txt to see what has been completed. \
2. Get the next issue from openissues.md. \
3. If there are no issues, output <promise>COMPLETE</promise> and exit. \
4. Complete the issue as required. \
5. If the issue requires code changes, make the necessary changes and commit them to GitHub. \
6. Ensure there are adequates tests for the changes you made. \
7. If the issue requires documentation changes, update the relevant documentation. \
8. Run the application and verify that the issue is resolved. Capture screenshots or logs as evidence of the fix. \
9. Update the GitHub issue with a comment describing how you resolved the issue, including any screenshots or logs. Close the GitHub issue as done. \
10. Append your progress to progress.txt with what you completed. \
11. If ALL tasks in openissues.md are complete, output <promise>COMPLETE</promise>. \
ONLY WORK ON ONE TASK PER ITERATION." > "$outfile" 2>&1 || {
    echo "Warning: Iteration $i failed (exit code $?). See $outfile for details. Continuing..."
    continue
  }

  cat "$outfile"

  if grep -q '<promise>COMPLETE</promise>' "$outfile"; then
    echo ""
    echo "openissues.md complete after $i iterations!"
    exit 0
  fi

  if (( i < $1 )); then
    sleep "$SLEEP_BETWEEN"
  fi
done

echo ""
echo "Reached $1 iterations. openissues.md may not be complete."

To execute you can just call

bash ralph.sh 100

This will run the loop 100 times, which in my case was enough to complete all 42, non-epic, GitHub issues.

And now you wait….. and wait…. and once you’ve verified that the first iteration doesn’t blow up and something is happening (you should see files being created and logs written)…. you can leave Ralph to it and come back in a few hours. I actually just went to bed and checked on the progress when I work up.

Ralph is Not a Designer

Actually, this should be Claude isn’t a designer, or at least is no substitute for a good UX designer. After working all night my Ralph loop and Claude had concocted what I’m sure is a fully functional app that meets my specifications. In fact, the over 1200 tests it created hopefully verifies that at least the functionality works. However, as the following screenshot of the MainPage will attest to, there was no thought towards building a usable interface.

There’s no doubt that Claude, Codex etc are all super powerful tools but if you don’t provide them with enough input, you’re at their mercy. In this case I’d come up with a detailed specification but hadn’t spent time working out what the UX should be. I ended up with a basic, input based, UX where there were CRUD style interfaces for each of the elements of the data model.

Summary

There are two clear takeaways from this. Firstly, building apps, even cross platform apps, has been dramatically condensed – we’re talking weeks, perhaps even months, of development down to a mere few hours. Secondly, that more time spent coming up with specifications, application flow, designs, will significantly improve the quality of the outcome.

From here I clearly need to spend more time with Claude coming up with a better UX for the application. In the past, this would have required reworking the application to adapt it to the new UX. However, since it only took a few hours to build the first version, and I don’t need to worry or care about users having to upgrade to a new version, why not completely rebuild the application from scratch!!! I’ll leave you with this thought – whether it’s better to adapt or rebuild, now that development cost isn’t what it used to be.

The post Ralph built a Cross-Platform app using Uno Platform whilst I slept. appeared first on Nick's .NET Travels.

Last post, I talked about the structural forces quietly grinding us down — the cost cutting, the helplessness, the grief of watching a craft you built your identity on shift beneath your feet.

This post is about what burnout in the tech industry actually feels like in your body. In your life. On a Tuesday morning.

How banal, I often thought to myself — there I stood, knee-deep in a pool of wax, my embers barely visible. I stubbornly persisted on, in denial that my energy was running on empty reserves.

There is shame in it. A shame you have to bury for a while before it’s even touchable.

Covered in Muck

If you’re still reading this, perhaps you can relate. Perhaps you woke up this morning and suddenly noticed that you are covered in muck — several layers thick. You were moving too fast to see it before. Now it’s too thick to ignore. And it’s weighing you down. It’s become difficult to move. Difficult to think.

Texts go unanswered. You have just enough energy to send that one email — but that’s all the will your daily rations allow on your current reserves. Dreaming is an escape. Getting out of bed is just going through the motions.

You’ve been forcing yourself through the routines your responsibilities demand for so long that you’ve become so disconnected from yourself, you don’t know what you’d even want to do with your life if you had to choose.

But the room is so dark now, you don’t have a choice but to do something different. You can’t go on this way. Something has to change.

How did you get to this point? The details don’t matter right now. It’s too early. But the metaphor is enough.

Right now, you are covered in so much muck that you are essentially the human equivalent of one of those hard, hollow, chocolate Easter bunnies that don’t taste very good — and it’s muck, not chocolate. Worse.

When you look in the mirror, it still looks like you. You don’t see the muck when you’ve hit rock bottom. You see what looks like you, but doesn’t feel like you. You feel sluggish, stiff. It takes all your effort to move a muscle. (Who knew sitting with computers could cause literal physical exhaustion?)

It’s no wonder you’re feeling this way though. You’ve been covered in several layers of muck for a few years now — you felt heavier, more labored over time, but you could still move.

Rewind your life. Quick. Stop.

You remember the time when you were muck free. Younger. Earnest. Excited. Optimistic. Energetically pursuing the thing that gradually burns you out over time.

Take a deep breath and ready your thumb. The next part is a classic flip book animation of your life. Slowly, flip the pages until you get to the first sling of muck. Look at yourself — it was hardly noticeable. Keep going. A little faster. Faster through the years. The muck builds gradually over time.

And you, you are the hero. For so long this fast-forwarded stop-motion review of your life has been a story of Human Triumph. Brave perseverance. Even as the muck gets thicker, you push through. You get stronger. So strong you don’t notice the muck is heavier. And then there is the climactic blow. It’s more of a spiritual blow. The muck layers consistently. For some reason, you can’t bounce back as easily.

Now, it’s obvious why. Looking back on the chapters, the animated flip book makes clear what is impossible to notice in real time: that you were the slow-boiling frog — but instead of boiling water, this metaphor covers you in muck.

Helplessness. Despair. Anger. Shame. They are buried too — baked into the hardened surface currently restricting your spirit.

Numbness. Exhaustion. Emptiness.

That’s all that’s left to feel.

I know that feeling. And if you’re reading this now and can relate — maybe you are feeling the cold concrete rock bottom with your bare hands today — congratulations.

Your new chapter starts today.

“Stay gold, Ponyboy.”

— The Outsiders

Coming up in Part 3: Everyone gets out of the hole a little differently. I’ve been where you are. I’m your techgirl guide — and I’m going to show you the map.1

Today, we’re introducing a new Postman platform built for the agentic era, with a full-stack of capabilities to help teams take their APIs from dev to prod for internal, external, and agentic use. It integrates directly with Git-based workflows and introduces several new capabilities: Git-connected Workspaces, an API Catalog that serves as a management plane for APIs and services across an organization, and an updated Private API Network for internal API distribution.

Over the past several months, we have been shipping at a blazing pace, and today marks a dramatic leap forward. We’re consolidating these improvements alongside some entirely new capabilities, all informed by a simple reality: AI agents are driving a platform shift. Similar to what happened with cloud and mobile, this shift is changing what infrastructure needs to look like underneath.

Agents are systems that are built on top of APIs — both deterministic (non-LLMs)  and probabilistic (LLMs). Unlike pre-AI software that followed deterministic code paths, agents take probabilistic actions — they decide at runtime what to call, when to call it, and how to chain calls together. This makes APIs the authoritative interface between agents and the real world. If an agent gets bad data from an API or an API is unreliable, the downstream effects compound quickly.

To succeed in the agentic era, engineering teams need APIs that are reliable, well-documented, and stable enough to be consumed by systems they don’t fully control. At the business level, companies are having to make harder decisions about which APIs to expose, which to protect, and how to price access.  Importantly, these decisions matter more when your API is serving an agent that might call it thousands of times a day rather than an application used by humans.

APIs have always been hard to build. They sit on top of stacks of underlying services, sometimes hundreds of them, and changing them without breaking consumers is a real engineering problem. As APIs become load-bearing infrastructure for agentic systems, getting this right becomes more critical. Postman has been part of the development and testing workflow for APIs across most of this history. What we’ve heard consistently from teams is that they need more: a single place to see all their APIs and services, tighter integration with how they already write and ship code, and the ability to enforce governance and reliability standards without doing it manually at each team.

Millions of developers already rely on Postman today. The new capabilities described below are how Postman meets what agentic development actually requires, for them, and for every team now building the systems that depend on APIs to work.

A new development experience

The new Postman app is Git-Native from the ground up. This means developers can work in Postman on the same branch they’re writing code on, alongside their IDE, and the Git-Native architecture enables Postman to work in offline conditions too.

We are also introducing new code-based local mock servers that can run locally as well as in the test loop with your CI system. This new mocking framework enables a level of flexibility that wasn’t possible before with just static mocking. Mock servers can now be made much more central to the development experience towards designing new APIs or services or stubbing out dependencies.

Postman Specs and Postman Flows are also integrated into the local workflows, and all your assets are versioned alongside your code. The new Collection v3 format makes this practical: instead of JSON blobs, collections are broken into constituent YAML files that are easy to diff, easy for humans to review, and easy for AI agents to read and write.

Expanded multi-protocol support

Modern systems rarely rely on a single protocol, but most tooling still treats each one separately. Postman now lets teams organize HTTP, GraphQL, gRPC, MCP, MQTT, WebSockets, and AI requests in the same collection and automate and validate workflows across HTTP, GraphQL, and gRPC in Collection Runner, with more protocols coming. The result is system-level testing that reflects how systems actually behave end-to-end, without the coordination overhead that comes from validating each part in a different tool.

A more capable Postman CLI

The Postman CLI now lets developers run the same collections, tests, and mocks locally and in CI without reconfiguring workflows for each environment.

Historically, local tests and CI pipelines live in different tools, which means local tests get rewritten for CI, mocked dependencies can’t be reproduced in pipelines, and gaps in coverage show up only after a commit. When the same workflows run in both places, failures surface earlier and the class of bugs that only appear in CI largely disappears.

The CLI also handles publishing, pushing artifacts to the Postman cloud for distribution through private, public, and partner networks.

Postman AI and Agent Mode

Postman AI operates as both a coach and an active participant in your workflow. Developers can use it conversationally, task it with completing workflows end to end, and have it work directly on the codebase to fix errors, generate server stubs, or produce client code. Postman assets can be created from scratch just by pointing AI at your code.

The core of this is Agent Mode, an AI that works across Postman and connected repositories. It acts on your existing data, editing and updating collections, tests, and mocks, and building new ones that follow your organization’s standards. Because it works natively with every Postman capability, developers save time at each step without switching tools or changing how they work.

Additional capabilities can also run through Agent Mode. AI Test Generation automatically adds contract, load, unit, integration, and end-to-end tests to APIs, reducing manual test creation, increasing coverage, and catching regressions before they reach production. AI debugging brings the same intelligence to Collection Runner, monitors, and performance runs. When a test fails, Agent Mode can diagnose the root cause and propose a fix directly in the run results, cutting the time developers would otherwise spend inspecting requests, variables, and environments one by one.

A more organized UI

Postman users told us they want a clean, information-dense design that adapts to their workflows and can expand as their needs change. Our new interface is built around that, with several structural changes that keep the core of the product intact.

The centerpiece of the new UI is a unified workbench. Collections, environments, specs, flows, and local mock servers can now live together and be organized however makes sense for the work at hand. Panels in the left sidebar can be shown, hidden, or created as the workflow demands, so developers can work across everything relevant to their development process at once instead of switching between separate contexts. Agent Mode ties this together by operating across multiple entities simultaneously.

Cloud services, including cloud mock servers, monitors, and insights, also get their own dedicated panel rather than being folded into the same view as local objects.

The history panel has been expanded to include modified elements alongside requests and collection runs, making it easier to track changes while working with Git. And a new file editor lets developers edit and create files directly in the Git folder connected to their workspace. Git workflows are native throughout: there’s a code editor, a terminal, and a new modifications UI for pushing and pulling changes without leaving Postman.

The new API Catalog

Most engineering organizations today have no single place that answers basic questions about their APIs: What APIs do we have? Are they tested? Are they compliant with our standards? How are they performing in production?

This information is scattered across Git repos, CI dashboards, APM tools, wikis, and tribal knowledge. Platform engineering teams spend significant time just assembling a picture of their API landscape, and that picture is usually incomplete and stale by the time it’s assembled.

The new Postman API Catalog solves this. It is a live operational layer for API portfolio management that functions as a system of record that stays current because it is directly connected to where your APIs are built, tested, and run.

The API Catalog gives engineering teams a single pane of glass for every API and service in their organization. Through the catalog, teams can observe their entire API landscape irrespective of the infrastructure those APIs have been deployed into, and across all the environments they run in.

The catalog is not just a list. It incorporates API governance, so central teams can enforce design rules. It provides analytics so leadership can measure API health at scale. And it is built to be AI-native. Using Postman’s Agent Mode, users can talk to the catalog in natural language to understand their system architecture, investigate metrics, or troubleshoot when something breaks.

Example queries

1. “Which APIs in production don’t have an OpenAPI spec?”
2. “Show me all APIs owned by the payments team that failed CI this week.”
3. “What are the upstream dependencies of the checkout service?”
4. “Which endpoints have P95 latency above 500ms in staging?”
5. “Are there shadow endpoints in the user-auth service?”

Agent Mode has access to the full catalog data model, so it can reason across governance, testing, and runtime data in a single query. Users can go from inspecting a problem to implementing a fix instantly.

Postman Private API Network

Postman’s Private API Network has been updated on both the publisher and consumer side.

For publishers, changes from Git now sync automatically to the network via the Postman CLI, so the network stays current without manual updates. Structure is handled through the new Organizations capability: every workspace published to the network is automatically grouped under the team that owns it, keeping things organized as the network grows.

Reporting has also been consolidated. Internal, partner, and public workspace analytics now live in a single destination instead of being spread across multiple pages with inconsistent views. The charts have been cleaned up as well. Engineering managers can get a clear picture of API usage and value across the organization without hunting across different parts of the product.

For consumers, a new UI introduces a purple badge to identify approved workspaces in Search and Agent Mode. Agent Mode is now available across the network surface, so consumers can query documentation and find the right APIs conversationally rather than manually browsing. The result is an internal API landscape that works as a live storefront for both humans and agents, discoverable, governed, and always in sync with the source.

Enterprise Organizations

Organizations give enterprises a way to group multiple Postman teams under a single organization, aligned to how the business is actually structured. Identity, access, and resources are managed centrally, while individual teams retain the autonomy to move at their own pace.

At scale, most enterprises face the same challenges: workspace sprawl, accidental oversharing, and no clear picture of who can access what. With Organizations, org-level governance paired with team-level management means admins get the control and auditability they need without becoming a bottleneck for every team that wants to ship.

Get started with these features today

All of these features (and more) are available starting today, and you can check out our documentation to read more about how they work. If you’re an existing customer, you can upgrade by going Settings (gear icon) > App Settings > Update, or grab the latest version from  our downloads page.

New to Postman? Sign up and start building.

The post The New Postman is Here: AI-Native and Built for the Agentic Era appeared first on Postman Blog.

Jenny Wen leads design for Claude at Anthropic. Prior to this, she was Director of Design at Figma, where she led the teams behind FigJam and Slides. Before that, she was a designer at Dropbox, Square, and Shopify.

—

We discuss:

1. Why the classic discovery → mock → iterate design process is becoming obsolete

2. What a day in the life of a designer at Anthropic looks like, including her AI tool stack

3. Whether AI will eventually surpass humans in taste and judgment

4. Why Jenny left a director role at Figma to return to IC work at Anthropic

5. The three archetypes Jenny is hiring for now

6. Why chatbot interfaces may be more durable than most people expect

—

Brought to you by:

Mercury—Radically different banking: https://mercury.com/?utm_source=lennys&utm_medium=sponsored_newsletter&utm_campaign=26q1_brand_campaign

Orkes—The enterprise platform for reliable applications and agentic workflows: https://www.orkes.io/

Omni—AI analytics your customers can trust: https://omni.co/lenny

—

Episode transcript: https://www.lennysnewsletter.com/p/the-design-process-is-dead

—

Archive of all Lenny's Podcast transcripts: https://www.dropbox.com/scl/fo/yxi4s2w998p1gvtpu4193/AMdNPR8AOw0lMklwtnC0TrQ?rlkey=j06x0nipoti519e0xgm23zsn9&st=ahz0fj11&dl=0

—

Where to find Jenny Wen:

• X: https://x.com/jenny_wen

• LinkedIn: https://www.linkedin.com/in/jennywen

• Substack: https://jennywen.substack.com

• Website: https://jennywen.ca

—

Where to find Lenny:

• Newsletter: https://www.lennysnewsletter.com

• X: https://twitter.com/lennysan

• LinkedIn: https://www.linkedin.com/in/lennyrachitsky/

—

In this episode, we cover:

(00:00) Introduction to Jenny Wen

(04:23) Why the traditional design process is dead

(06:33) The two new types of design work

(10:00) How widespread this shift will be

(13:00) Day-to-day life as a designer at Anthropic

(18:45) Jenny’s AI stack

(20:03) Why Figma still matters for exploration

(22:25) Advice for working with engineers

(24:19) How to maintain craft, quality, and trust in the AI era

(27:35) Will AI ever have “taste”?

(31:38) The future of chatbot interfaces

(35:33) Moving from director back to IC

(41:00) The 10-day build of Claude Cowork

(46:06) Hiring: the three archetypes

(50:44) Advice for new and senior designers

(54:42) The value of “low leverage” tasks for managers

(57:52) Why the best teams roast each other

(01:01:45) The legibility framework

(01:07:22) Lightning round and final thoughts

—

Referenced:

• Figma: https://www.figma.com

• Anthropic: https://www.anthropic.com

• v0: https://v0.app

• Navigating a Design Career with Jenny Wen | Figma at Waterloo: https://www.youtube.com/watch?v=OHcBPMh2ivk

• Claude Cowork: https://claude.com/product/cowork

• Use Claude Code in VS Code: https://code.claude.com/docs/en/vs-code

• Claude Code in Slack: https://code.claude.com/docs/en/slack

• Lex Fridman’s website: https://lexfridman.com

• Head of Claude Code: What happens after coding is solved | Boris Cherny: https://www.lennysnewsletter.com/p/head-of-claude-code-what-happens

• OpenClaw: https://openclaw.ai

• OpenAI’s CPO on how AI changes must-have skills, moats, coding, startup playbooks, more | Kevin Weil (CPO at OpenAI, ex-Instagram, Twitter): https://www.lennysnewsletter.com/p/kevin-weil-open-ai

• Marc Andreessen: The real AI boom hasn’t even started yet: https://www.lennysnewsletter.com/p/marc-andreessen-the-real-ai-boom

• Socratica: https://www.socratica.info

• Anthropic’s CPO on what comes next | Mike Krieger (co-founder of Instagram): https://www.lennysnewsletter.com/p/anthropics-cpo-heres-what-comes-next

• Radical Candor: From theory to practice with author Kim Scott: https://www.lennysnewsletter.com/p/radical-candor-from-theory-to-practice

• Evan Tana’s ‘legibility matrix’ on X: https://x.com/evantana/status/1927404374252269667

• How to spot a top 1% startup early: https://www.lennysnewsletter.com/p/how-to-spot-a-top-1-startup-early

• Palantir: https://www.palantir.com

• Stripe: https://stripe.com

• Linear: https://linear.app

• Notion: https://www.notion.com

• Julie Zhuo’s website: https://www.juliezhuo.com

• Sentimental Value: https://www.imdb.com/title/tt27714581

• The Pitt on Prime Video: https://www.amazon.com/The-Pitt-Season-1/dp/B0DNRR8QWD

• Noah Wyle: https://en.wikipedia.org/wiki/Noah_Wyle

• ER on Prime Video: https://www.amazon.com/gp/video/detail/B0FWZSDYRP

• Retro: https://retro.app

• Granola: https://www.granola.ai

—

Recommended books:

• Radical Candor: Be a Kick-Ass Boss Without Losing Your Humanity: https://www.amazon.com/Radical-Candor-Kick-Ass-Without-Humanity/dp/1250103509

• The Power Broker: Robert Moses and the Fall of New York: https://www.amazon.com/Power-Broker-Robert-Moses-Fall/dp/0394480767

• Insomniac City: New York, Oliver Sacks, and Me: https://www.amazon.com/Insomniac-City-New-York-Oliver/dp/162040494X

—

Production and marketing by https://penname.co/. For inquiries about sponsoring the podcast, email podcast@lennyrachitsky.com.

—

Lenny may be an investor in the companies discussed.