Mark Makary Blog

Welcome to the World of Vibe Coding

“Vibe coding” is the shorthand everyone is using now: you describe the outcome, the AI builds the scaffolding, and you guide the work instead of typing every line yourself. That pattern works in almost any language. What changes is how each language responds to the AI’s guidance—and for a backend that functions as a real business engine, not a weekend toy, that difference matters.

Imagine the brief: build an API that ingests real-time stock ticker data, calculates a few technical indicators, and pushes updates to a trading dashboard the moment the market opens. You open your AI assistant and ask it to choose a path.

Python: Fast to Build, Flexible to a Fault

Python moves first. It is familiar, expressive, and eager to sketch. FastAPI spins up quickly. The AI wires in a WebSocket feed, pulls from a data provider’s SDK, and handles the indicator calculations. Within forty minutes, you have a working dashboard. Python does not just let you write code quickly; it lets you improvise with the AI, and at first that feels like exactly what you wanted.

Then the market opens. Thousands of users load the dashboard at once, all watching the same tickers. Latency climbs. You ask the AI to fix it, and it does: caching, async workers, and a queue to smooth the burst. Each fix works in isolation, but one quietly opens a race condition two files away. Two updates land out of order, and a stale price gets averaged into a moving average.

Nothing crashes. Nothing throws an error. The dashboard simply shows a number that is wrong, and someone may act on it. Python is not dishonest about this risk; dynamic typing just does not force the AI to prove enough before the code ships.

Go: Less Improvisation, More Guardrails

Go answers the same brief differently. Goroutines handle ticker subscriptions natively. Structs replace implicit shortcuts. Every function has to be explicit about what happens when something fails. The code may be less charming to read, but the moment you run go build, Go stops you before a single request is served.

That stop is the point. Go surfaces type mismatches, unsafe shared state, and missing error handling early. It does not let the conversation move forward until the disagreement is resolved.

Where Do You Want the Mistake to Show Up?

That is the real question hiding inside “Would you vibe Go or Python?” The AI is not automatically more careful in either language. The language decides how willing it is to let the AI be wrong quietly—and in anything touching money, quiet is the expensive kind of wrong.

This is not a simple “Go wins” verdict. If the work is backtesting a strategy or training a model on historical prices, Python’s ecosystem is still the sensible choice, and it will get you to a demo faster than almost anything else. The distinction is where you find out the AI made a mistake—and what that timing costs given what the API is actually for.

• Python tends to reveal more issues at runtime, sometimes in front of a user—or a trade.
• Go pushes more issues into the build step, before the code ever runs.
• The best choice depends less on developer preference and more on the cost of being wrong late.

That distinction reflects what is happening across the industry. Developers are adopting AI coding tools quickly, while trust in the code those tools produce has not kept pace. Independent reviews of AI-authored code continue to find logic errors and security misconfigurations that matter in production systems.

Other Contenders Worth Mentioning

• Rust — unmatched performance and safety, but with a steep learning curve.
• Node.js — strong for I/O-heavy APIs, but less ideal for CPU-bound work.
• Java/Kotlin — enterprise-grade, but heavier and less “vibe-friendly.”
• Elixir — excellent concurrency model, but supported by a more niche ecosystem.

So, would you vibe Go or Python, others, I would love to hear your thoughts?