I’m trying something a bit new, writing some of my thoughts about how the future might look based on patterns I’ve been observing lately.

From where I’m sitting, it seems language models are positioned to become an indispensable tool for the software engineer. While there continues to be advancement in model-driven agents which can autonomously accomplish software-creation tasks of increasing complexity, it’s not clear if or how long it will take these to completely replace the job function responsible for writing, testing, deploying and maintaining software in a production environment. If we accept the premise that the job of software engineer will exist in some capacity for the next several years, it becomes interesting to explore how widespread use of language models in software development will affect the job and evolution of the field.

I spent some time working with Claude Artifacts for the first time. I started with this prompt

I want to see what you can do. Can you please create a 2d rendering of fluid moving around obstacles of different shapes?

In effort to not spend this whole post quoting prompts I need to figure out a better way to share conversations from all the different models I interact with, including multi-modal models. Ideally, I could export these in a consistent JSON structure to make rendering them in a standard conversation format easier. Static media (images, video, etc.) would be straightforward but things like Artifacts, which are rendered by the Claude UI fit this structure less cohesively. , I’ve exported the whole conversation returned from the Anthropic API, using the response from the following endpoint This API may change in the future. It isn’t an externally-documented API. .

Temporal provides helpful primitives called Workflows and Activities for orchestrating processes. A common pattern I’ve found useful is the ability to run multiple “child workflows” in parallel from a single “parent” workflow.

Let’s say we have the following activity and workflow (imports omitted for brevity)

Activity code

@dataclass
class MyGoodActivityArgs:
    arg1: str
    arg2: str


@dataclass
class MyGoodActivityResult:
    arg1: str
    arg2: str
    random_val: float


@activity.defn
async def my_good_activity(args: MyGoodActivityArgs) -> MyGoodActivityResult:
    activity.logger.info("Running my good activity")
    return MyGoodActivityResult(
        arg1=args.arg1,
        arg2=args.arg2,
        random_val=random.random(),
    )

Workflow code

I spent some time experimenting with multi-modal model (also called vision models on the ollama site) to see how they perform. You try these out with the CLI ollama run <model> but I opted to use the ollama Python client.

I didn’t find explicit documentation in the README on how to pass images to the model but the type hints in the code made it pretty easy to figure out and there are several examples around Github. The docs also note the client is modeled around the REST API which has an example request using an image.

One of my favorite things to do with language models is to use them to write code. I’ve been wanting to build a variation on tic-tac-toe involving a bit of game theory. I called it “Tactic”. I wasn’t even really sure if the game would be any more interesting than tic-tac-toe itself, which reliably ends in draws for any players who understand the basics of the game. Rather than explain too much, I’ll show the prompt I wrote for claude-3.5-sonnet using Workbench. Try it yourself! You will probably receive a response quite similar to what I got. Related: I need to start saving my model conversations in a consistent format.

Model-based aggregators

I watched Simon’s Language models on the command-line presentation. I am a big fan of his Unix-approach to LLMs. This also inspired me to play around more with smaller models to continue developing an intuition for how these things work.

I was quite interested in his script which he used to summarize comments on an orange site post at 26:35 in the video. This script got me thinking about the future of information consumption more deeply. I found Simon’s script useful for understanding the general tone of the responses to a particular item posted on the forum.

I completed Barbara Oakley’s “Learning How to Learn” course on Coursera. The target audience seems to be students, but I found there were helpful takeaways for me as well, as someone who is a decade out of my last university classroom.

The course introduces a mental model (no pun intended) for how the brain works by contrasting two modes: focus mode and diffuse mode. Being in one of these modes prevents you from being in the other. For me, it helped provide some insight into why at some times things like coding, being creative, and writing can be more difficult than others.

I’ve been using Pocket for a long time to keep track of things on the web that I want to read later. I save articles on my mobile or from my browser, then revisit them, usually on my desktop. Some articles I get to quickly. Others remain in the stack for a long time and can become stale. Periodically, I scan through everything I’ve saved and do a bit of house cleaning.

Generative AI and language models are fun to play with but you don’t really have something you can confidently ship to users until you test what you’ve built.

What are evals?

Evals are like the unit tests for LLMs. Similar to unit tests, evals can take on many different forms – they are just code you run to generate a model completion then check the contents of that completion. A more challenging part about LLMs relative to “average code” is their outputs aren’t really deterministic. Let’s think about non-deterministic (less-deterministic?) code for a second. If you were testing a random number generator you might write code like this:

Similar to (and perhaps more simply than) analyzing Youtube video transcripts with language models, I wanted to apply a similar approach to webpages like articles, primarily for the purposes of determining the subject content of lengthy pieces and experimenting to see if this is useful at all.

The html2text script is good at extracting content from html. When combined with a few other CLIs, we can prompt the language model to create a summary for the cleaned HTML page.