Co-Evolving Human Interfaces and Language Models: The Future of Code and Documentation

When AI language models (LMs) like Claude, Perplexity, SearchGPT, and Gemini start to integrate deeply into our daily workflows, the line between "agent" and "environment" begins to blur. This shift isn’t just about building better LMs; it’s about how the digital world is adapting to these new users. Codebases, websites, and documents are evolving in ways that optimize for both humans and LMs.

How It Begins: The Codebase Adaptation

When coding alongside tools like GitHub Copilot, you might notice subtle changes in your behavior. One significant shift is the rise of "docstring-first programming." This approach leverages the model's ability to generate code snippets based on descriptions. Here’s how it works:

• Docstring-First Programming: You start by writing a comment or a descriptive function name, then pause to let Copilot suggest the rest. For example:

  # Function to calculate the factorial of a number
  def factorial(n):
      if n == 0:
          return 1
      else:
          return n * factorial(n-1)
  

• Chunk-by-Chunk Commenting: This method leads to more heavily commented code, which is beneficial for both human readability and LM comprehension.

The result is a codebase that looks different from one written without LMs in mind. The environment adapts to the tool, making it easier for both humans and LMs to understand and work with the code.

Beyond Code: The Library Developer’s Perspective

As a library or framework developer in 2024, you can expect that many of your users will be interacting with your tools through coding assistants. This means building for LMs is now part of being "dev-friendly." For instance:

• FastHTML by Jeremy Howard: This project includes llm-ctx files, which are documentation intended specifically for LMs rather than humans.
  • Human-Friendly Docs: Rich, visually organized, and often interactive (e.g., docs.fastht.ml).
  • LM-Friendly Context: Information-dense text optimized for LM consumption (e.g., llms-ctx.txt).

This dual approach reflects a new, parallel world where content is tailored to both human and machine users.

Agent-Computer Interfaces: Optimizing for LMs

The principle of adapting interfaces for LMs extends beyond code. To make LM agents work better, you need to provide them with the right context in a format they can understand. This applies to various applications:

• Websites: Designing web pages that are easily parseable by LMs.
• GUIs: Creating user interfaces that can be navigated and understood by both humans and LMs.
• Documents: Writing documents that include metadata and structured information for LM processing.
• Spreadsheets: Organizing data in a way that is accessible to LMs.

For example, FastHTML’s llm-ctx files provide dense, structured text that helps LMs understand the library’s functionalities. This approach ensures that both human developers and AI assistants can effectively use the framework.

The Future of Digital Environments

As the digital world continues to evolve, we must consider how it will adapt to the increasing presence of LMs. This isn’t just about building better models; it’s about creating end-to-end systems where agents and environments co-adapt. Here are some key takeaways:

• Code Adaptation: Docstring-first programming and chunk-by-chunk commenting make code more accessible to both humans and LMs.
• Dual Documentation: Creating human-friendly and LM-friendly documentation ensures that all users can benefit.
• Adaptive Interfaces: Designing interfaces that cater to both human and machine users will be crucial for future applications.

In this co-evolution, the digital landscape becomes a dynamic environment where agents and environments continuously influence each other. As researchers and developers, we need to think beyond just improving models and focus on building systems that thrive in this new, interconnected world.