Beyond the Prompt Box: Building Notion AI’s Interfaces

A paragraph you can paint

To change a paragraph’s tone, a writing demo at the first San Francisco AIUX meetup let users drag a brush onto the text. Each brush represented a tone or writer-inspired style; a language model performed the rewrite. Alessio remembers the interaction as dragging an emoji over a paragraph. Linus identifies it as Amelia’s demo: a writing tool that exposed an operation directly, without requiring another typed instruction.

Linus had explored semantic sliders: controls for a sentence’s length, positive or negative sentiment, and even how philosophical it should be. Adjusting them prompted a model to produce new text. Amelia’s brushes offered discrete presets; the sliders offered continuous control. Both turned aspects of writing into something users could manipulate.

These experiments introduce the question running through the June 2023 conversation: how should software expose a model’s capabilities? Swyx organized the meetup when Linus, Geoffrey Litt, and Maggie Appleton were all in San Francisco. Linus recalls a packed Notion office, with machine-learning practitioners and people focused on human–computer interaction sharing an interest in unconventional interfaces.

Make the experiment small enough to ship

Linus’s advice for exploring this space begins with scope. Combining the GPT-4 API, vector databases, and Next.js in one learning project can create several unfamiliar problems before anything becomes usable. A compelling idea can turn into weeks of work that are difficult to finish alongside a day job.

His rule is one unfamiliar technology per project. Estimate the familiar work using your actual working speed, then fit a shippable result into one available block of time—Friday night through Sunday night, for example. The new ingredient might be an embedding API or vector operations in PyTorch. Once something ships, using it yourself or seeing others use it supplies momentum for extending it.

Deep familiarity with a consistent toolset reduces lookup time and unfamiliar debugging. The tools discussed include Go, a personally built language, and familiar libraries. Monocle, Linus’s personal search engine, included a custom full-text index. Sharing its implementation made interesting techniques available for inspection; easy replication and mass adoption were secondary.

Shape the task before tuning the model

Language-model applications can serve three different kinds of work: - Content generation: produce prose with relatively little machinery around the model. - Knowledge synthesis: search, interpret, and combine existing context. - Automation: propose actions or generate code that accomplishes a task. The proposed progression follows the work behind a document. Much knowledge work aims to understand a situation, synthesize ideas, or decide what to do. Generating the written artifact addresses only part of that process.

Supporting that broader work creates a tension between flexibility and intuitiveness. A general model accepts a vast range of requests, while useful interfaces often make a few actions obvious. The design framework proposed here starts with tasks the model handles well, then adds constraints that guide both users and the system toward them. Those constraints should also communicate what users can expect.

Consider a hypothetical knowledge-base assistant. Present its input as a messaging window and people may send greetings, comments, or unrelated questions. Present the same box as a search bar with a search button and inputs are more likely to resemble keywords or lookup questions. The interface changes the input distribution—the range and frequency of requests the model receives. Narrowing that range makes behavior easier to tune and gives users a clearer starting point.

Early experiences with Notion AI illustrate the discovery problem. One participant reports people using it for emails, marketing copy, and Instagram ads, while some friends who tried it struggled to find a place for it in their own workflows. In these informal conversations, recognizing an impressive capability did not necessarily reveal a useful personal task.

An interviewer raises the value of open-ended prompting for discovering unexpected uses. The response favors guided actions with a general-purpose escape hatch. Notion’s Writer, AI blocks, and AI Autofill offered curated prompts alongside custom instructions. Custom prompts served power users and let the community invent templates and workflows the team had not anticipated. That diversity could also inform future improvements to prompts or models.

Choose abstractions that can outlast the technology

The career account begins with web engineering at mostly seed-stage startups, followed by a year of independent exploration in 2022. Deliberately accumulated savings covered a year and some additional time; professional relationships provided confidence that work could be found if necessary. One question focused the research: how could text interfaces improve? AI became a means of answering it as computers gained new ways to interpret text. The year became an AI career pivot in retrospect.

Notational Intelligence, a piece written during that exploration, argued that specialized representations help people manipulate higher-level concepts. Mathematical and chemical notation make concepts easier to work with than raw words or unaided mental representations. Text is highly general, but specialized notation can offer more useful ways to operate within a particular domain.

A participant asks whether constraints alone can enable invention. The account of joining Notion points to another opportunity: early successful products can establish lasting interaction conventions. Notion appeared to combine enough speed to prototype and ship experiments with enough adoption to learn from their use. It offered a chance to influence emerging defaults through interfaces people would actually encounter.

Familiarity can preserve those defaults after their original setting changes. QWERTY persists on small touchscreens; a simulated trackpad click can operate a simulated software button. These layers of inherited behavior also explain the appeal of skeuomorphism, which borrows the appearance or behavior of familiar objects. Its functional value lies in a consistent mental model that helps users predict an interaction. Such a model can simplify the underlying system without imitating a physical object.

Give agents visible boundaries

Scheduling software offers a useful starting definition of an agent: software that performs delegated work without requiring the user’s participation at every step. Calendly and SavvyCal fit that definition even with deterministic behavior. Scheduling links still ask recipients to choose a time, which some experience as impersonal. An AI intermediary exchanging emails is proposed as a more personal interaction.

Delegation becomes harder when the task is less constrained. An interviewer describes asking an agent to prepare podcast background research and repeatedly supplying examples without getting the desired format. That failure raises a choice between open-ended assistants and task-specific agents, with specialists potentially adding the burden of remembering which agent to trust for each task.

The response connects trust and control. An unwanted result may indicate an unreliable agent, but it may also indicate that the interface makes intent difficult to communicate. Easier controls over format, behavior, and scope could reduce reliance on the model interpreting an open-ended instruction correctly.

Notion’s AI blocks and autofilled cells provide spatial zones of influence: visible regions where AI-generated content belongs. They help distinguish the model’s contribution from surrounding work, though they do not guarantee human authorship elsewhere. In collaborative software, the same principle extends to showing what an agent can access and what it changed. Permissions constrain future actions; edit history makes past actions inspectable.

Approval creates a scaling problem of its own. Confirming destructive actions is sensible, but a hundred agents could leave a user handling notifications all day. Two exploratory patterns are a limited undo window and batches of changes summarized for bulk approval. Human collaboration supplies useful precedents, while treating AI entirely as a human-like coworker can obscure its distinctive advantages.

From document assistance to background computation

Notion connects documents, wikis, meeting notes, and database-backed workflows through a shared block abstraction. Paragraphs, bullet points, and pages fit into the same conceptual system. A database is a collection of pages: dragging a paragraph into one makes it a page, while pulling a page out produces a link to it. The building-block metaphor extends to employee rituals—a Lego minifigure on joining, followed by a block marking each year.

The corresponding AI question remained open: what reusable building block could support many workflows? A secondhand account tentatively places the first prototype in an Ivan-and-Simon hack session around October 2022. The GPT-3 experiment connected to Notion’s ambition for end-user programming: helping people customize software for their needs without writing code. By the conversation, the strategy was to make AI as fundamental to the workspace as blocks and databases.

An established product limited radical redesign but also supplied direction. Existing users had recurring problems and recognizable workflows. Observing those workflows and early AI adoption narrowed the enormous space of possible features.

At the time, three product surfaces expressed different degrees of integration: - Writer generated summaries, extracted action items, drafted prose, and helped with editing, grammar, and spelling. - AI blocks embedded repeatable tasks within documents. The AI team’s meeting-note templates placed a block at the top; after a meeting, a button regenerated the summary and participants’ action items. - AI Autofill applied instructions to database properties. For user interviews, columns could extract companies, pain points, requested features, or competitor products from each page.

Autofill changed the execution model. Writer and AI blocks required users to request updates. An autofilled property could be configured to recompute when its row or page changed. Instructions resembling spreadsheet formulas became background automation tied to a specific part of the workspace.

Richer navigation through knowledge offered another direction. Code editors expose a graph of functions, call sites, tests, and types through go-to-definition and reference views. Prose has a less precise graph: terms connect to definitions and mentions; ideas connect to citations and disagreements. A document interface—or an AI—could traverse those relationships across a workspace. Backlinks would supply part of that context.

A simple button can hide a difficult prompt

A summary button has a narrow purpose, yet its inputs may include an empty page, a news article, meeting notes, or a bug report. Making that ordinary action behave appropriately across the full range is a substantial prompt-engineering problem.

The Notion AI prototype reportedly moved from instruction-following models to chat-based models, including Claude. Chat formatting made few-shot prompting—demonstrating desired behavior through examples—easier to organize. Examples became earlier conversation turns, followed by the actual task. The speaker found four or five demonstrations of edge cases easier to supply than an exhaustive prose specification.

Language choice was a consequential edge case. English instructions could pull a response into English even when the source document was French. In the speaker’s experience, multilingual demonstrations worked better than simply instructing the model to use the user’s language. Examples included an English document, a French ticket, and an empty document whose intended language was Korean.

As examples accumulated, some prompts grew to thousands of tokens. Regression testing checked whether changing an instruction or demonstration broke previously supported behavior. Cases combined handwritten examples with feedback users chose to share. The largely custom tooling was essentially a loop over test cases: supply a document and query, generate a response, then ask a language model whether it met criteria such as being a reasonable summary or using the correct language.

For a fixed testing budget, the speaker recommends spending more on the judging model than the generating model, while not recalling whether the team actually used different models. Evaluator preference for its own outputs was not a concern they reported having.

Long application prompts compete with user content for the context window, the finite amount of text a model can handle in a request. A short summary does not remove the limit on source-document length; the exchange acknowledges truncation in a 5,000-token translation example. Prompt compression through parameter-efficient fine-tuning was floated as a possible remedy. In 2023, Anthropic’s recently announced 100,000-token context also supported a decision to give prompt-length optimization lower immediate priority, on the expectation that longer, cheaper contexts would ease the constraint.

Turn a scene into shared engineering practice

Human–computer interaction and AI offer two approaches to making computers work better with people: improve interfaces or make machines smarter. One participant describes them as historically competing for funding, talent, and attention. AI interface design creates a place for those approaches to meet.

The distinction between a scene and a field, loosely recalled and credited to Andy Matuschak, is a shared set of tools, methods, standards, and core questions. Machine learning supplies the comparison: practitioners can draw on established techniques, benchmarks, and prior attempts. AI UX was characterized as energetic but still lacking much of that common foundation.

The proposed AI engineer role sits between software engineering and machine-learning research. Media, meetups, conferences, job titles, and shared questions could help establish that community. The idea of scenius places frequent exchange at the center of intellectual progress: close contact helps ideas develop. Online communities also offer participation beyond major cities.

Cheaper models invite more computation

The closing lightning round begins with surprise at falling token costs and growing access to long-context models. Limits that had seemed like enduring architectural constraints were changing quickly enough to force a reassessment. But cheaper inference can expand consumption: interfaces such as Autofill make bulk operations practical.

In one reported Autofill prototype test, summarizing roughly 6,000 generally long pages consumed approximately two to three million tokens in about twenty minutes and cost around five or six dollars. These were rough figures from a single scaling test, with no model or input/output token breakdown specified.

Against the roughly ten-dollar monthly Notion AI price mentioned in the conversation, one such operation could consume much of a subscription’s revenue. The example raised a unit-economics question about heavy usage, without establishing actual product profitability. An interface can absorb model efficiency gains simply by making much more work easy to request.

Make the decision inspectable

Linus’s final technical concern is predictability. Even a request for a bulleted list can produce different bullet characters, extra titles, or arbitrary bolding. Formatting variation is inconvenient in a writing tool; variable behavior becomes more consequential when software automates decisions.

For suitable structured tasks, he proposes having the model generate an explicit decision procedure. His example is date extraction: specify the date formats that matter, ask for a regular expression covering them, and execute it against the document. The resulting artifact gives people something to inspect and refine.

That program becomes a boundary object: a shared representation a human can examine and a computer can execute. Linus argues that running it repeatedly is cheaper than repeatedly invoking the model. It also provides a place to verify behavior, debug failures, and maintain the intended rule. Generating code begins an inspection and improvement process.

Language-model program synthesis and established program analysis can therefore work together. GPT-4 can turn a human description into an initial program; compilers, type checkers, and formal verification techniques can help reason about that program and prove properties of it. The proposed route to dependable automation combines flexible specification with explicit programs and tools for checking them.

Linus closes with a longer design horizon. Writing tools and document conventions may reflect historical circumstances rather than enduring requirements. He argues for prioritizing powerful, flexible tools over backward compatibility when thinking far into the future. He also predicts that something better than transformers could emerge within a couple of years—a personal forecast made in 2023. Both interface conventions and the models beneath them remain open to invention.