New Reflections on Software and Human-Computer Interaction

I've recently spent some time thinking about what “software,” something we use every day, really means. From its original role as a tool to today's wave of AI, I want to return to first principles and organize these scattered thoughts.

Software

From the user's perspective, software is primarily a tool and a means for helping people achieve goals and meet their needs.

• Achieving human goals
  • Entertainment: games, consuming content
  • Education: learning, acquiring skills
  • Work: productivity, collaboration
  • Daily life: food, clothing, housing, transportation, transactions, health
  • Social life: connection, communication
• Human needs (using Maslow as a “high-level framework”)
  • Physiological needs, safety, belonging, esteem, self-actualization, cognition, aesthetics, self-transcendence
• Separating “goals” from “needs”
  • Goal: the outcome we want to achieve
  • Need: what we care about while achieving that goal (efficiency, certainty, a sense of safety, control, competence, belonging…)
  • Product opportunities: frequent goals × deeply felt needs × structural shortcomings of existing tools

The Essence of Software

• Human habits, captured and abstracted
  • What
    • Understanding people is central: software is used by people and serves people
    • What software does: for a category of needs within a particular group, it abstracts a set of repeatable rules and processes that fit human habits
  • How
    • To abstract such rules, we first need to understand human characteristics: traits inherent in our genes + external changes that depend on time together shape how people do things. We build software around these characteristics to meet user needs.
    • Some characteristics of how people act are inherent in our genes; the process also depends on sequences of events over time and is shaped by external influences (in other words, cultivating user habits). But “habit cultivation” often simply brings out some of humanity's latent characteristics.
    • One way to understand these characteristics is through learning: deepen our understanding of people, recognize patterns in human habits, and predict likely behaviors. This is understanding + prediction. Another way is social experimentation: implement different versions and gather human feedback to uncover characteristics hidden in the real world.
    • An abstracted experience, as distinct from experiencing the content itself: Capture the underlying principles of an experience, not the experience itself.

Open video in new tab ↗

• Augmenting human capabilities (Augmentation: using software to do “what people cannot do, or cannot do well”). The human brain is sophisticated, but biological limits constrain its memory capacity and make large-scale concurrent thinking and action difficult.
  • “Thinking”
    • Exceptional computing power and parallelism: people tend to think linearly, while software has exponential processing capabilities. At the same time, turning experience into processes and templates (capture the underlying principles) makes “quality” more consistent
    • Extending memory without limit: counter the forgetting curve by externalizing knowledge and experiences into memory that can be searched, reused, and shared
  • “Acting”
    • Collaboration across time and space: extend individual capabilities into networked capabilities (collaboration, synchronization, accumulation)
    • Using tools: translate the movement of electrons into the movement of atoms, influencing the environment. The O2O model of the previous era is a typical example.

Software should therefore be seen as leverage. It not only “automates” existing habits, but also helps people accomplish tasks that their biological selves alone could not perform. This is the source of software's enormous value.

How Software Works

• Data mapping / representation transform
  • What software often does: maps one representation to another, performing computation, aggregation, filtering, sorting, and generation along the way
  • Once the world is “digitized,” two kinds of representations emerge
    • Mappings of the physical world: people, rooms, cars, stores, products, locations, time. For example, Airbnb, Uber, and DoorDash map people, rooms, cars, and stores into cyberspace.
    • Representations native to the digital world: relationship graphs (following/friends), credit scores, reviews, permissions and policies, workflow states. Other examples include Excel's calculations and displays, database joins/aggregation, and text/image/video editing

Human-Computer Interaction (HCI): A Compromise and a Way to Manage Costs

Fundamentally, interfaces exist because machines are not yet intelligent enough, making them a necessary “compromise.”

• Why interfaces exist. To turn ideas and needs into actions performed by tools more conveniently, and obtain results. People need to find tools suited to them to achieve their goals and meet their needs. Different people have different needs and habits, and there are many corresponding tools. The best tools fit user needs and align with user habits; these are also the products most likely to retain users. User needs are an abstract concept and require boundaries or scope: they usually arise from “one frequently repeated task” or “a chain of events that often occur together.” These naturally create boundaries.
  • Levels of experience in fulfilling intentions and needs
    • Ideal: an intention arises -> the need is immediately met (Zero UI).
    • Next best: the intention is expressed -> the need is met.
    • Reality (HCI): the intention is expressed -> learning/operation/effort -> the need is met.
  • When machines cannot yet reliably understand human intent, people can only express it in more explicit, structured ways; interaction therefore becomes a “cost of compromise.”
    • Good interaction does not mean “making users do more”; it means minimizing total cost
  • Feedback Loop
    • Action → change in system state → user understanding → next action (repeat)
    • A practical check: the system should continuously answer
      • What happened (feedback/visibility)
      • Where are we now (state/progress)
      • What if something went wrong (recoverability: undo, rollback, paths to correction)
• The evolution of interfaces (from the command line to today)
  • Early days: DOS/terminal + command line (command line / CLI), where users type commands and the computer returns results or performs actions
  • Later: websites, apps, and various GUIs
  • My interpretation of this evolution: the less intelligent the machine, the more complex an interface people need to express intentions and constraints
  • An interesting comparison: if we brought LLMs into the “command-line” era, the earliest form of human-computer interaction might instead resemble chat (a chatbot); today's chatbots/agents are also bringing it back.

The LLM Era: Interaction Moves from “Control” to “Collaboration”

• A change we must acknowledge: LLM feedback is probabilistic. Much of the feedback in traditional software is deterministic (a save succeeds/fails, a like turns red), while LLM output can vary and even “look right while being wrong.” We should therefore care more about mechanisms for trust than about being “right every time”
  • Verifiable: output can be checked (citations/evidence/a path to reproduction)
  • Traceable: what the system did and why
  • Recoverable: errors can be corrected at low cost (undo/rollback/alternatives)
  • Controllable: users control permissions, scope, cost, and risk
• Pull vs Push: from responding passively to serving proactively (agents), provided the boundaries are clear.
  • Pull: the user acts and the system responds (most software today)
  • Push: the system serves proactively based on predictions (agents). Push should require not only “more intelligence,” but also “more control”
    • Authorizable: permissions and goals are granted explicitly
    • Bounded: scope (time/objects/amounts/area of impact) is configurable
    • Revocable/reversible: disable with one action, undo actions, restore state
    • Auditable: users can see logs (what was done, why, and which data was used)
    • Able to step down: automatic execution can become a suggestion/draft/pending confirmation at any time

Which human-computer interactions could offer a better experience with large language models, reducing interaction complexity and better fitting the nature of how people interact with computers? I welcome discussion in the comments.