ai posts - idmontie's Portfolio

"use strict";
const {Fragment: _Fragment, jsx: _jsx, jsxs: _jsxs} = arguments[0];
function _createMdxContent(props) {
  const _components = {
    a: "a",
    img: "img",
    p: "p",
    ...props.components
  };
  return _jsxs(_Fragment, {
    children: [_jsxs(_components.p, {
      children: ["In 2008, Steve Ballmer once famously said “", _jsx(_components.a, {
        href: "https://www.youtube.com/watch?v=Vhh_GeBPOhs",
        children: "Developers, developers, developers"
      }), "” in a highly meme-able video. He was trying to emphasize the importance of software developers in business and that their importance was only going to continue to grow. Microsoft shifted to try to support software developers, noticing that if they supported developers, they would build better software for Windows, which in turn would make people want to use Windows."]
    }), "\n", _jsx(_components.p, {
      children: "The 2010s saw companies like “Twilio” have guiding questions like Jeff Lawson’s “Why Isn’t That and API?”. This guiding principle was based around the idea that if you build great APIs for software developers, they would want to use them, and in doing so, spend money on those services. For that entire decade, companies would start, build for engineers, and use the fly-wheel effect to become multi-billion dollar companies."
    }), "\n", _jsx(_components.p, {
      children: _jsx(_components.img, {
        src: "/media/2025-04-21-agents-agents-agents/why-isnt-that-an-api.png",
        alt: "Why isn't that an API?"
      })
    }), "\n", _jsxs(_components.p, {
      children: ["Now, in the age of LLMs (Large Language Models) and AI, my assumption about the future is that we are going to find that “AI Agents” are the next Big Thing. We will probably see software engineers coding not to make APIs that other developers can use, but so that AI Agents can use. With ", _jsx(_components.a, {
        href: "https://openai.com/index/introducing-operator/",
        children: "OpenAI introducing Operator"
      }), ", their AI that can do tasks for you autonomously, the trajectory looks clear for companies that want to partner in this space: make products that will interface with AI Agents*."]
    }), "\n", _jsxs(_components.p, {
      children: ["And this isn’t going to only apply to software engineering. Even those in marketing are starting to think about how their content can be better consumed by the crawlers that feed into the training data for these LLMs. In “", _jsx(_components.a, {
        href: "https://benjamincongdon.me/blog/2025/01/25/AI-Slop-Suspicion-and-Writing-Back/",
        children: "AI Slop Suspicion and Writing Back"
      }), "”, the author hypothesizes about the future of SEO. Will we be writing not for other people to reach our content via search, but to see our content as part of an LLM’s answer to a question? If people are starting to transition to asking LLMs like ChatGPT a question first before they even Google, then wouldn’t getting your name and your thoughts ingested by the massive corpus of training data be beneficial in a sense, similar to a web-crawler indexing for search?"]
    }), "\n", _jsx(_components.p, {
      children: "These are questions I think we will see answered very soon, and some of the answers may not be ones we like. We may very well be starting to write content, apps, and APIs not for other people, but for machines."
    }), "\n", _jsx(_components.p, {
      children: "*Of course, not everyone is going to jump on this bandwagon. There are companies right now that make concerted efforts to make sure only humans use their site. They don’t have APIs, they stick their entire site behind a Cloudflare captcha check. These aren’t the companies I’m talking about as they weren’t trying to bridge into the larger software developer ecosystem."
    })]
  });
}
function MDXContent(props = {}) {
  const {wrapper: MDXLayout} = props.components || ({});
  return MDXLayout ? _jsx(MDXLayout, {
    ...props,
    children: _jsx(_createMdxContent, {
      ...props
    })
  }) : _createMdxContent(props);
}
return {
  default: MDXContent
};


In 2008, Steve Ballmer once famously said “<a href="https://www.youtube.com/watch?v=Vhh_GeBPOhs">Developers, developers, developers</a>” in a highly meme-able video. He was trying to emphasize the importance of software developers in business and that their importance was only going to continue to grow. Microsoft shifted to try to support software developers, noticing that if they supported developers, they would build better software for Windows, which in turn would make people want to use Windows.
The 2010s saw companies like “Twilio” have guiding questions like Jeff Lawson’s “Why Isn’t That and API?”. This guiding principle was based around the idea that if you build great APIs for software developers, they would want to use them, and in doing so, spend money on those services. For that entire decade, companies would start, build for engineers, and use the fly-wheel effect to become multi-billion dollar companies.
<img alt="Why isn&#x27;t that an API?" src="/media/2025-04-21-agents-agents-agents/why-isnt-that-an-api.png" style="max-height:500px;margin:auto;text-align:center"/>
Now, in the age of LLMs (Large Language Models) and AI, my assumption about the future is that we are going to find that “AI Agents” are the next Big Thing. We will probably see software engineers coding not to make APIs that other developers can use, but so that AI Agents can use. With <a href="https://openai.com/index/introducing-operator/">OpenAI introducing Operator</a>, their AI that can do tasks for you autonomously, the trajectory looks clear for companies that want to partner in this space: make products that will interface with AI Agents*.
And this isn’t going to only apply to software engineering. Even those in marketing are starting to think about how their content can be better consumed by the crawlers that feed into the training data for these LLMs. In “<a href="https://benjamincongdon.me/blog/2025/01/25/AI-Slop-Suspicion-and-Writing-Back/">AI Slop Suspicion and Writing Back</a>”, the author hypothesizes about the future of SEO. Will we be writing not for other people to reach our content via search, but to see our content as part of an LLM’s answer to a question? If people are starting to transition to asking LLMs like ChatGPT a question first before they even Google, then wouldn’t getting your name and your thoughts ingested by the massive corpus of training data be beneficial in a sense, similar to a web-crawler indexing for search?
These are questions I think we will see answered very soon, and some of the answers may not be ones we like. We may very well be starting to write content, apps, and APIs not for other people, but for machines.
*Of course, not everyone is going to jump on this bandwagon. There are companies right now that make concerted efforts to make sure only humans use their site. They don’t have APIs, they stick their entire site behind a Cloudflare captcha check. These aren’t the companies I’m talking about as they weren’t trying to bridge into the larger software developer ecosystem.


In 2008, Steve Ballmer once famously said “[Developers, developers, developers](https://www.youtube.com/watch?v=Vhh_GeBPOhs)” in a highly meme-able video. He was trying to emphasize the importance of software developers in business and that their importance was only going to continue to grow. Microsoft shifted to try to support software developers, noticing that if they supported developers, they would build better software for Windows, which in turn would make people want to use Windows.

The 2010s saw companies like “Twilio” have guiding questions like Jeff Lawson’s “Why Isn’t That and API?”. This guiding principle was based around the idea that if you build great APIs for software developers, they would want to use them, and in doing so, spend money on those services. For that entire decade, companies would start, build for engineers, and use the fly-wheel effect to become multi-billion dollar companies.

![Why isn't that an API?](/media/2025-04-21-agents-agents-agents/why-isnt-that-an-api.png)

Now, in the age of LLMs (Large Language Models) and AI, my assumption about the future is that we are going to find that “AI Agents” are the next Big Thing. We will probably see software engineers coding not to make APIs that other developers can use, but so that AI Agents can use. With [OpenAI introducing Operator](https://openai.com/index/introducing-operator/), their AI that can do tasks for you autonomously, the trajectory looks clear for companies that want to partner in this space: make products that will interface with AI Agents*.

And this isn’t going to only apply to software engineering. Even those in marketing are starting to think about how their content can be better consumed by the crawlers that feed into the training data for these LLMs. In “[AI Slop Suspicion and Writing Back](https://benjamincongdon.me/blog/2025/01/25/AI-Slop-Suspicion-and-Writing-Back/)”, the author hypothesizes about the future of SEO. Will we be writing not for other people to reach our content via search, but to see our content as part of an LLM’s answer to a question? If people are starting to transition to asking LLMs like ChatGPT a question first before they even Google, then wouldn’t getting your name and your thoughts ingested by the massive corpus of training data be beneficial in a sense, similar to a web-crawler indexing for search?

These are questions I think we will see answered very soon, and some of the answers may not be ones we like. We may very well be starting to write content, apps, and APIs not for other people, but for machines.

*Of course, not everyone is going to jump on this bandwagon. There are companies right now that make concerted efforts to make sure only humans use their site. They don’t have APIs, they stick their entire site behind a Cloudflare captcha check. These aren’t the companies I’m talking about as they weren’t trying to bridge into the larger software developer ecosystem.


Agents, Agents, Agents

"use strict";
const {Fragment: _Fragment, jsx: _jsx, jsxs: _jsxs} = arguments[0];
function _createMdxContent(props) {
  const _components = {
    mermaid: "mermaid",
    p: "p",
    ...props.components
  };
  return _jsxs(_Fragment, {
    children: [_jsx(_components.p, {
      children: "We are starting to see a rise of novel use-cases for AI in products and games using LLMs. Rather than the simple chatbot like experiences we have seen in the past using AI, we are starting to see feedback systems being added to these experiences, providing additional context to the LLM than just the past conversation."
    }), "\n", _jsx(_components.p, {
      children: "A typical game loop for this type of system would look like:"
    }), "\n", _jsx(_components.mermaid, {
      chart: "graph LR\n  Rules --> LLM\n  InputStates[\"Input States\"] --> LLM\n  LLM --> OutputState\n  OutputState[\"Output State\"] --> GameEngine\n  GameEngine[\"Game Engine\"] --> InputStates"
    }), "\n", _jsx(_components.p, {
      children: "Rules can be describes as written-word description, with an additional set of rules telling the LLM to reply using JSON output of a given schema. In this area, I have had success giving LLMs descriptions of output schemas in Typescript and asking for a JSON response that adheres to the type. Other methods of getting a consistent schema are more than likely possible here, as well as additional output methods."
    }), "\n", _jsx(_components.p, {
      children: "When the asynchronous task of creating and output state is complete, the Game Engine in this case can read, parse, and apply that new state to the world. Any additional interaction would then lead to the next set of input states that can be given to the LLM as a JSON blob."
    }), "\n", _jsx(_components.p, {
      children: "For a more concrete example, we can imagine a game where we want our player to interact with a set of agents. The input states would be the state of each agent, the user’s interaction, and maybe some global environment data. The rules may be how each agent should behave, the rules of the game, and additional context. The LLM would take these inputs, and the output is instructed to be the next state of each agent. When the LLM returns this data, the Game Engine read it and applies it to the game’s representation of each agent, showing the player the impact of their actions."
    }), "\n", _jsx(_components.p, {
      children: "I’m looking forward to more novel use-cases for LLMs!"
    })]
  });
}
function MDXContent(props = {}) {
  const {wrapper: MDXLayout} = props.components || ({});
  return MDXLayout ? _jsx(MDXLayout, {
    ...props,
    children: _jsx(_createMdxContent, {
      ...props
    })
  }) : _createMdxContent(props);
}
return {
  default: MDXContent
};


We are starting to see a rise of novel use-cases for AI in products and games using LLMs. Rather than the simple chatbot like experiences we have seen in the past using AI, we are starting to see feedback systems being added to these experiences, providing additional context to the LLM than just the past conversation.
A typical game loop for this type of system would look like:
<mermaid chart="graph LR
 Rules --&gt; LLM
 InputStates[&quot;Input States&quot;] --&gt; LLM
 LLM --&gt; OutputState
 OutputState[&quot;Output State&quot;] --&gt; GameEngine
 GameEngine[&quot;Game Engine&quot;] --&gt; InputStates"></mermaid>
Rules can be describes as written-word description, with an additional set of rules telling the LLM to reply using JSON output of a given schema. In this area, I have had success giving LLMs descriptions of output schemas in Typescript and asking for a JSON response that adheres to the type. Other methods of getting a consistent schema are more than likely possible here, as well as additional output methods.
When the asynchronous task of creating and output state is complete, the Game Engine in this case can read, parse, and apply that new state to the world. Any additional interaction would then lead to the next set of input states that can be given to the LLM as a JSON blob.
For a more concrete example, we can imagine a game where we want our player to interact with a set of agents. The input states would be the state of each agent, the user’s interaction, and maybe some global environment data. The rules may be how each agent should behave, the rules of the game, and additional context. The LLM would take these inputs, and the output is instructed to be the next state of each agent. When the LLM returns this data, the Game Engine read it and applies it to the game’s representation of each agent, showing the player the impact of their actions.
I’m looking forward to more novel use-cases for LLMs!


We are starting to see a rise of novel use-cases for AI in products and games using LLMs. Rather than the simple chatbot like experiences we have seen in the past using AI, we are starting to see feedback systems being added to these experiences, providing additional context to the LLM than just the past conversation.

A typical game loop for this type of system would look like:

```mermaid
graph LR
  Rules --> LLM
  InputStates["Input States"] --> LLM
  LLM --> OutputState
  OutputState["Output State"] --> GameEngine
  GameEngine["Game Engine"] --> InputStates
```

Rules can be describes as written-word description, with an additional set of rules telling the LLM to reply using JSON output of a given schema. In this area, I have had success giving LLMs descriptions of output schemas in Typescript and asking for a JSON response that adheres to the type. Other methods of getting a consistent schema are more than likely possible here, as well as additional output methods.

When the asynchronous task of creating and output state is complete, the Game Engine in this case can read, parse, and apply that new state to the world. Any additional interaction would then lead to the next set of input states that can be given to the LLM as a JSON blob.

For a more concrete example, we can imagine a game where we want our player to interact with a set of agents. The input states would be the state of each agent, the user’s interaction, and maybe some global environment data. The rules may be how each agent should behave, the rules of the game, and additional context. The LLM would take these inputs, and the output is instructed to be the next state of each agent. When the LLM returns this data, the Game Engine read it and applies it to the game’s representation of each agent, showing the player the impact of their actions.

I’m looking forward to more novel use-cases for LLMs!


Agents, Agents, Agents

AI Feedback Systems