Guides to building with AI

What these are

Each guide covers one idea and then shows it running. The pages about markets read a live perpetual market as they load, so the figures in them came from an exchange rather than from an author, and the pages about tooling link to a template you can fork and have running in a browser tab within a minute. Nothing here is a description of a product feature waiting for you to sign up before you can see it.

How to use the list

The four groups below run from the general to the specific. If you have not built anything yet, start in Building with AI. If you are already using an agent and want to know why it forgets things halfway through a task, Code, agents and tools has the answer. Compared with other builders is the honest version of where we differ from Lovable, Cursor and Bolt, which is narrower than a marketing page would claim. Markets and trading assumes no finance background and defines its terms.

Building with AI

• Vibe coding, with something real underneathVibe coding means describing an app instead of writing it; the difference between a demo and a working result is whether the generated code can reach something real, like a live market, that will contradict it when it is wrong.
• An AI app builder where the app has to workAn AI app builder turns a description into a running app; the ones that produce working software rather than convincing mockups are the ones whose generated code can read a real data source at runtime.
• An app builder for apps that answer questionsMost app builders assemble interfaces well, and assembly is no longer the hard part; what remains hard is reaching something real, handling it being slow or wrong, and saying so honestly on screen.
• An AI app generator, and what it costs to skip the boring partsAn AI app generator will produce a running app from a description in minutes, and the parts it tends to skip are error handling, staleness and what to show when a data source is unreachable, which are precisely the parts that decide whether the app is still working in a month.
• Build an app with AI, and the part everyone skipsBuild an app with AI and you get an easy first hour and a hard second day: the demo runs on data invented to make it render, and connecting it to something real is where the actual work begins.
• A no code app builder, until the data gets hardNo-code app builders handle forms, tables and workflows well because that data is yours and sits still; they strain when the data lives outside your system and changes while you look at it.
• An AI website builder, and when you need more than a websiteAn AI website builder is the right tool whenever your content is stable; the moment a page has to show a price, a rate or a balance that changes, it has become an app and needs a live data source rather than a nicer layout.
• Build a website with AI, and know when you have outgrown oneBuild a website with AI whenever the content is written once and stays true; the moment a page has to show something that changes while a visitor is reading it, it has stopped being a website and needs a live data source rather than a better layout.
• Choosing AI tools by how fast you find out they were wrongThe most useful question when choosing an AI tool is not what it can do but how quickly you would find out it had done something wrong, because tools whose output is checkable in seconds compound in your favour and tools whose mistakes surface days later compound against you.
• Building a blockchain explorerA blockchain explorer is an index over chain data, and building a general one is a database problem rather than a web problem, which is why the version worth building is usually narrow: the addresses you care about, the tokens you hold, and whether a particular transaction landed.
• Building a currency converterA currency converter is a multiplication and a rate, so the whole job is the rate: which of the three prices you use, how recently it was read, and what the screen says when the source that supplies it stops answering.
• A net worth tracker, and the ages of its numbersA net worth tracker sums values that were each read at a different time and with a different confidence, so the useful version of the tool shows the age and the source of each part rather than one total presented to the penny.
• APY vs APR, and tracking rates without comparing unlike thingsA savings rate tracker is a table of numbers that mean slightly different things, APY vs APR being the first of them, so the work is normalising them to one convention, recording when each was read, and being honest that a higher rate usually reflects a different risk rather than a better offer.

Code, agents and tools

• An AI code generator you can checkAn AI code generator is close to solved on the generating and not on the checking; pointing generated code at a live market turns correctness from a matter of judgement into something the data contradicts within seconds when it is wrong.
• An AI coding assistant that can check its own workAn AI coding assistant writes code faster than you can type it, but cannot tell you whether the reasonable-looking version is correct, because nothing in the loop ran it against anything that would object.
• A coding agent, and the difference from an autocompleteThe difference between a coding agent and an autocomplete is that an agent acts and then observes, so its usefulness depends almost entirely on whether the things it can observe actually tell it the truth about what it did.
• AI agents, and the question that decides whether one is usefulAn AI agent is a model, a loop and a set of tools, and since the first two are close to identical everywhere, what an agent can actually do is decided almost entirely by what its tools can reach and how honestly those tools report failure.
• Agentic AI, and the part that is usually missingAgentic AI is a model that takes actions and then observes their results in a loop, which means its usefulness depends less on how well it reasons than on whether the things it observes can contradict it.
• An AI agent builder, and the part that decides whether it worksAn AI agent builder is only as useful as the tools it can hand an agent, so the hard part of building one is not the prompt or the loop but deciding what it can actually reach and what happens when a tool answers slowly, wrongly, or not at all.
• An MCP server, and what makes one worth connectingThe hard part of an MCP server is not the protocol, which is well specified and quick to implement, but the design of the tools themselves: what they are named, what they return, and above all what they say when they fail, because a model that receives an unhelpful error will retry and then invent.
• Model Context Protocol, explained without the diagramModel Context Protocol is a standard interface between a model and a set of tools, so that any client speaking it can use any server exposing them; it solves the wiring and deliberately leaves the hard questions of naming, scope and failure reporting to whoever writes the server.
• Retrieval augmented generation, and when not to use itRetrieval augmented generation is the right tool for text that does not change, and the wrong tool for anything with a current value, because a retrieval step answers from a copy made at indexing time rather than from the source.
• Prompt engineering, and the part that is really specificationMost prompt engineering is not a set of tricks but the ordinary work of specifying a problem precisely, which is why the techniques keep expiring while the skill of stating clearly what you want, what you have, and how the result will be judged keeps working.
• API integration, and the part that is not the integrationThe difficult part of an API integration is not making the call but handling refusal: rate limits, authentication that expires, errors that arrive as a successful response, and the browser rules that make code working in a terminal fail in a page.
• The context window, and why bigger is not simply betterA larger context window removes the constraint of not fitting and introduces the constraint of relevance, because a model given a great deal of loosely related material attends less well to the part that mattered, so what you include matters more than how much you could.
• An AI workflow, and the step that has to be able to say noAn AI workflow only becomes reliable when at least one step can refuse the one before it, because a chain in which every step succeeds by definition will run to completion on wrong input and report that it worked.
• Webhooks, and why receiving one is the easy halfThe hard part of webhooks is not receiving them but handling duplicates and losses, because senders retry on any doubt and will deliver the same event more than once, while an event you failed to process is gone unless you stored it.
• AI automation, and the difference between a task and a decisionAI automation is reliable on tasks whose result can be checked immediately and unreliable on decisions whose consequences arrive later, so the useful line is not how hard the work is but how quickly you would notice it being done wrong.
• Cursor vs Claude CodeCursor vs Claude Code comes down to this: Cursor is an editor you drive, where the AI suggests and edits the file in front of you, and Claude Code is a terminal agent you brief, which plans and edits across many files on its own, so the difference that lasts is where the work starts rather than any feature either one has this month.
• Vector databases, and when a column will doA vector database stores embeddings and answers nearest-neighbour questions over them, and the thing you are really buying is an index that trades recall against latency and memory, which is why the honest question is not whether to use one but whether your scale needs a dedicated one.

Compared with other builders

• A Lovable alternative for apps that need live dataLovable is a strong AI app builder for product interfaces, so the case for a Lovable alternative is narrow and specific, and it is whether the app you are describing has to read a live financial market.
• A Cursor alternative when you do not want to open an editorThe case for a Cursor alternative starts with what Cursor is: an AI code editor that assumes you have a project open; a builder assumes you want a running app and will read the code if you need to, which suits a different moment rather than a different skill level.
• A Bolt alternative for apps that read a live marketThe case for a Bolt alternative is narrow: both are prompt-to-running-app builders, and where they differ is whether the app has to be correct about a live market, because a generated dashboard is only as honest as the data source behind it and a model with nothing real to read will produce convincing invented numbers instead.
• A Claude Code alternative for when you want the app, not the repositoryA Claude Code alternative is worth looking at when you do not have a repository yet: Claude Code edits a project you already own from the terminal, and a builder takes a description and returns a running hosted app with the code available, which is a different starting point rather than a different skill level.
• A Replit alternative built around live market dataA Replit alternative makes sense when the app has to read a live market: Replit is a general browser IDE with an agent, and this is a narrower builder whose generated apps call keyless public endpoints for prices, funding rates and order books, so they show real figures rather than placeholders.
• A TradingView alternative you build once instead of subscribing toA TradingView alternative is worth building rather than subscribing to when you want one specific view rather than a general platform: this describes generating your own dashboard that reads live prices, funding rates and order books from keyless public endpoints, which you host and own outright.
• A GitHub Copilot alternative for people who are not in an editorA GitHub Copilot alternative is a different tool rather than a better one: Copilot completes code inside an editor you are already using, and a builder takes a description and returns a whole running app, so it fits the moment before there is a file to type in.
• A Streamlit alternative that does not need PythonA Streamlit alternative suits people whose work is not in Python: Streamlit wraps a Python script in a web interface and needs a server running it, and this generates a static app from a description that reads live data in the browser, so there is no process to keep alive.
• A Softr alternative for apps whose data is a market, not a tableA Softr alternative is the right question when your data is not a table you maintain: Softr builds an interface over records in a database you keep up to date, and this generates apps that read live market data from public endpoints at render, so there is nothing to keep current.
• A v0 alternative for apps that need real numbers in themA v0 alternative matters when the interface has to contain real figures: v0 generates the components and fills them with sample content, and this generates the app already reading live prices, funding rates and order books from keyless public endpoints.
• A Retool alternative for market dashboards rather than internal toolsA Retool alternative is the right question when the data is a public market rather than an internal system: Retool connects to your databases behind your authentication, and this generates dashboards that read keyless public market endpoints and publish as a static site you own outright.
• A Metabase alternative for live markets rather than a warehouseA Metabase alternative is the right question when the data is a live market rather than a warehouse: Metabase queries a database you maintain and caches the result, and this generates dashboards that read public market endpoints at render, where a figure a few minutes old is already wrong.
• A Cline alternative for when there is no project open yetA Cline alternative is useful before a project exists: Cline operates on an open workspace in your editor and needs one, and a builder takes a description and returns a running hosted app with exportable code, so it covers the step that comes first.

Markets and trading

• Crypto arbitrage, and why most of it is already goneMost crypto arbitrage is closed by bots before a person can act, so the useful question is not where the gaps are but why a visible gap has survived: halted withdrawals, congestion, a book too thin to fill, or fees that exceed the edge.
• A trading dashboard is only as good as its refreshA trading dashboard showing a price from four minutes ago looks identical to one showing a price from four seconds ago, so the thing that makes one useful is not its layout but whether it states when each number was read.
• An AI dashboard, and the number that is missing from most of themThe difficult part of an AI dashboard is not drawing the charts but knowing how old the numbers are, because a figure with no read time cannot be acted on and a dashboard that hides a dead data source looks exactly like one that is working.
• A financial dashboard, and the three numbers most of them get wrongThe hard part of a financial dashboard is not the layout but deciding what each figure means, how old it is allowed to be, and what to show when the source is unreachable, because a stale number and a current one are visually identical and only one of them is safe to act on.
• Perpetual futures, and the funding rate that holds them to spotA perpetual future is a futures contract with no expiry, held close to the spot price by a funding payment between longs and shorts, which makes funding a cost of time rather than a fee on trading.
• A crypto trading bot is mostly risk codeMost of the code in a working crypto trading bot is not the strategy, it is position sizing, failure handling and the conditions under which it stops trading, because a strategy that is right most of the time can still lose everything on the occasion it is not.
• AI trading bots, and where the difficulty actually isThe difficult parts of an AI trading bot are not the prediction but the plumbing around it: how stale its view of the market is, what fees do to a small edge, what happens when an order only partly fills, and how it behaves when the venue rejects it.
• A crypto portfolio tracker, and the number most of them get wrongMost crypto portfolio trackers value a holding at the last traded price, which is the number you could sell one unit at rather than the number you could sell your position at, and the gap between those two is largest exactly when it matters most.
• AI trading, and the distinction that matters mostAI trading is genuinely useful for building tools, dashboards, scanners, monitors and alerts, and is not reliably useful for predicting prices; the distinction matters because the first is checkable within seconds and the second cannot be evaluated until it is too late.
• Algorithmic trading, and where the difficulty actually sitsIn algorithmic trading the strategy is usually the shortest part of the code, and the difficulty sits in execution, position sizing and the conditions under which the system stops, because a strategy that is right most of the time can still lose everything on the occasion it is not.
• Backtesting, and the four ways it lies to youIn backtesting, a good-looking result is the default rather than a discovery, because four errors reliably produce one: look-ahead bias, survivorship bias, overfitting, and ignoring costs, and a result that has not been checked against all four says almost nothing about the future.
• Survivorship bias, and what an interface can do about itSurvivorship bias is drawing a conclusion from the things that are still here, when the things that are gone were the ones that would have changed it, and it is hard to catch because the missing rows leave no trace in the data or in the interface showing it.
• Web3 development, and the part that is just distributed systemsMost web3 development is ordinary engineering, and the genuinely different parts are three constraints: state changes are slow and can fail after you thought they succeeded, everything you write is public and permanent, and there is no support line when a user loses access.
• Net interest margin, or what the gap in your savings rate buysNet interest margin is the gap between what a bank earns lending your deposit and what it pays you to hold it, and most of that gap buys four specific things: deposit insurance, a licence and the supervision behind it, a rate that does not move while you sleep, and the right to withdraw on demand.
• The gold silver ratio, and what it does not tell youThe gold silver ratio is the gold price divided by the silver price, so it says how many ounces of silver one ounce of gold currently buys, and it moves mostly because silver is the more volatile of the two rather than because anything has been revealed about either metal.
• Prediction markets, and what the price is actually telling youA prediction market turns a question into a tradeable contract that pays a fixed amount if the answer is yes, so its price is a probability in cents, and reading it well means knowing what the price includes beyond the forecast itself.