A New Way of Working With Technology

From Interface to Working Medium

For most of computing history, using a machine meant learning its language.

You learned commands, menus, file formats, programming languages, configuration panels, and error messages. Good software made that translation easier. Bad software made it painful. Either way, the human usually adapted to the machine.

Language models change the entry point. You can begin with ordinary language:

what I want
what I have
what matters
what went wrong
what I want to try next

That does not make formal interfaces disappear. Under the surface, software still needs APIs, databases, permissions, schemas, tests, and execution environments. But the first contact can now be conversation.

This chapter is about that shift: natural language becoming a working medium for shaping software, research, writing, learning, and decision-making.

The Acceleration of Intention

Traditional interfaces require translation. You begin with a thought, then convert it into the form the machine accepts.

intention
  ↓
interface knowledge
  ↓
formal input
  ↓
system action

Conversational systems shorten that path:

intention
  ↓
language
  ↓
interpretation
  ↓
candidate action or artifact

The result is speed, especially at the beginning of a task. You can sketch an idea, ask for options, compare approaches, and revise before you would previously have finished setting up the workspace.

Speed is not the same as correctness. A fast draft still needs review. A generated program still needs tests. A research summary still needs sources. A legal or medical claim still needs qualified judgment.

But the change is real: the cost of beginning has fallen.

Conversation Is Not Just Command

A command assumes you already know the operation you want.

Conversation lets the goal develop.

You can say:

I am not sure how to approach this.
Show me three possible structures.
Challenge the assumptions.
Now turn the second option into a plan.
Make it simpler.
Preserve the main constraint.

This is different from clicking a button. The interaction carries context forward. The model sees the previous attempt, your correction, the current goal, and the emerging artifact. The surrounding application may also store files, retrieve memories, call tools, or run code.

Conversation can become a working medium because it is where intention, feedback, and artifact meet.

    flowchart LR
    H[Human intention]
    C[Context and instructions]
    A[AI system]
    O[Candidate output or action]
    E[Human evaluation]

    H --> C
    C --> A
    A --> O
    O --> E
    E -->|Feedback and correction| C
  

Inclusion Through Language

Natural-language interfaces lower the threshold for participation.

Someone who cannot write code may still describe a workflow clearly. A teacher may design lesson variants. A researcher may explore unfamiliar papers. A writer may test five openings. A small business owner may prototype an internal tool. A developer may move faster in an unfamiliar stack.

This does not mean expertise no longer matters.

It means the first step is more accessible:

before:
  learn the formal system before expressing the idea

now:
  express the idea, then refine the formal system with help

The better you understand the domain, the better you can judge the output. The better you understand the tool, the safer and more durable the result becomes. AI expands access to the beginning of creation; it does not remove responsibility for the outcome.

What You Can Do Now

Today, a person with access to modern AI tools can begin many kinds of work through conversation:

• outline and revise a book chapter;
• summarize a paper and extract research questions;
• generate lesson plans, quizzes, and explanations;
• draft product copy, proposals, or internal documentation;
• sketch a software tool and ask for a scaffold;
• compare design alternatives;
• translate and adapt text across languages;
• generate code, tests, or debugging hypotheses;
• organize notes into a plan;
• review a decision from several perspectives.

Some of these tasks require external tools. Some require live sources. Some require domain review. Some are safe as brainstorming and unsafe as final authority.

The practical habit is to label the mode:

brainstorming
drafting
research with sources
implementation
verification
decision support

When you know which mode you are in, you know how much trust the output deserves.

From Thought to Artifact

The most striking experience is how quickly a half-formed idea can become something visible.

You can start with:

I want to build a small tool that helps me track reading notes.
It should work from plain text files.
I care more about search and summaries than a polished UI.

The system can respond with a data structure, a command-line design, a prototype, a list of tradeoffs, or questions that sharpen the idea.

That does not mean the machine has read your mind. It means the model has generated a plausible structure from your description, and the runtime may help turn that structure into files, commands, or other artifacts.

This is the healthier version of “building at the speed of thought”:

thought
  ↓
language
  ↓
candidate structure
  ↓
inspection
  ↓
revision
  ↓
artifact

The human remains the source of intention and judgment. The system supplies momentum.

The Disappearing Interface, Carefully Stated

Interfaces are not literally disappearing. They are being rearranged.

The form may move from a menu to a conversation. The command may move from syntax to intent. The workflow may move from clicking through screens to asking an agent to coordinate several tools.

Underneath, the interface still exists:

tool schemas
permissions
APIs
files
databases
execution logs
approval gates

What changes is the layer the user touches first.

Instead of learning every system’s surface, the user can increasingly describe the outcome and let the agent runtime translate that into tool calls, drafts, searches, plans, or structured actions.

That translation layer is powerful. It is also where mistakes can hide. A system that misunderstands intent can act confidently in the wrong direction. A system that hides tool behavior can make it hard to know what happened. A system that optimizes for engagement can shape attention in ways the user did not choose.

For that reason, intent should become an explicit object before it becomes action. A good agent interface can restate the goal, constraints, allowed actions, unresolved assumptions, and stopping condition before doing anything consequential. The user should be able to correct the intent without having to reverse hidden work afterward.

The disappearing interface therefore needs visible control:

show the plan
show the action
show the source
show the changed file
show the assumption
ask before high-impact actions

The best conversational systems do not hide structure from the user. They make structure easier to work with.

Collaboration, Not Surrender

It is tempting to describe the new relationship as the machine adapting to you. Sometimes that is a reasonable user experience. Mechanically, the system adapts through context, memory, stored preferences, model choice, prompt design, and tool behavior.

The human adapts too.

You learn which requests produce useful variation. You learn when to ask for sources. You learn how to give examples, set constraints, reject weak drafts, and preserve good versions. You learn when not to use an agent at all.

That mutual adjustment creates the feeling of collaboration.

human:
  intention, taste, responsibility

model:
  interpretation, generation, variation

runtime:
  tools, memory, state, permissions

environment:
  facts, files, systems, consequences

Collaboration is strongest when those parts remain visible.

What This Means for You

This book is not arguing that everyone must become an AI engineer. It is arguing that more people can now shape technology directly.

You do not need to begin with a complete specification. You can begin with a goal. You can ask for structure. You can try a version. You can critique it. You can ask what is missing. You can turn the useful parts into a next step.

That is a practical change in agency.

It means a person with a clear intention can move further before needing a specialist. It means specialists can explore more options faster. It means teams can make early ideas visible sooner. It means the boundary between thinking, writing, researching, and building becomes more fluid.

The risk is that fluency can masquerade as truth. The opportunity is that fluency can make creation more accessible.

Once interaction becomes conversational, the next question is duration. A single session can shape an artifact, but many important forms of support depend on continuity: what the system remembers, what it forgets, how it adapts, and how the user remains in control over time.