{"id":289,"date":"2024-10-08T08:52:52","date_gmt":"2024-10-08T08:52:52","guid":{"rendered":"https:\/\/joskodeboer.nl\/?p=289"},"modified":"2026-04-10T14:45:00","modified_gmt":"2026-04-10T14:45:00","slug":"will-genai-replace-developers","status":"publish","type":"post","link":"https:\/\/joskodeboer.nl\/index.php\/2024\/10\/08\/will-genai-replace-developers\/","title":{"rendered":"Will genAI replace developers?"},"content":{"rendered":"
\"AI<\/span><\/div><\/div>

We've all heard the rumors that we - the developers - will be replaced by genAI soon. The layoffs in recent years have been concerning to say the least.<\/p>\n

In this blog post, I'll introduce you to cursor AI and draw my own conclusions regarding my imminent replacement by that which I help create.<\/p>\n

The challenge I gave myself is to build a boardgame with reinforcement learning with only prompting - I'm not allowed to code. The result is on GitHub<\/a>.<\/p>\n

Note that this post isn't sponsored, it's just an interesting example of current developments with generative AI assisted workflow.<\/p>\n

 <\/p>\n<\/div><\/div><\/div><\/div><\/div>

What is Cursor AI?<\/h2>\n<\/div><\/div>

Cursor is a code editor, but with LLM enhancements. First, it enhances the common suggestion\/autocomplete feature into multiple edits at once. When you start coding, it sees what you did and does exactly what LLMs are made for: It predicts what you'll code next.<\/p>\n

It allows you to type carelessly; it autofixes typos, drawing from both the language constructs and your own context (e.g. variable names).\u00a0<\/p>\n

A really cool feature is that you can use\u00a0CTRL+L<\/em> to open a chat with the LLM. It will have the context of your current file, and you can ask it questions about the code. This can go from \"Can you explain what the current module does\" to \"Can you spot any bugs in this file\"?\u00a0<\/p>\n

In any interaction with the LLM, you can use the @ symbol<\/a> to add context - other code files. So, you might be able to ask more complicated questions such as \"When we take this file together with @src\/logic\/utilities.py, what can we do?\". The chat suggests changes to your code that can be applied immediately.<\/p>\n

Inside your code, you can open a smaller chat window and give direct instructions. You can select code or just \"cursor\" in your file, and tell it how the code should be changed. The same window can also be turned into a \"quick question\", so that you don't need to open the full chat.<\/p>\n

See more on Cursor's features.<\/a><\/p>\n

 <\/p>\n<\/div><\/div>

My test case: The boardgame cryptid<\/h2>\n<\/div><\/div>

My test case is a boardgame?<\/p>\n

Yes! Let me explain my reasoning. First off, I wanted something with a certain degree of complexity to really put Cursor through it's paces. After all, creating API endpoints for different tables is something we can automate without LLMs, but creating a fairly complex boardgame, using smart algorithms to find different answers and using reinforcement learning to create automated bots for the game should offer a far greater challenge!<\/p>\n

 <\/p>\n<\/div><\/div><\/div><\/div>

<\/span><\/div><\/div>

Cryptid is a boardgame in which three to five players try to find \"the cryptid\". To this end, you first pick a random scenario card. The card specifies how to put down the six parts of the map, and which player receives which \"hint\". A hint is something like \"The cryptid can be found either on water or in a forest\". Throughout the game, you are questioning the other players, trying to determine what each of their hints are so that you can be the first to find the cryptid.<\/p>\n<\/div><\/div><\/div><\/div>

There's a few features to the map. Each tile has a terrain type: Forest, Swamp, Desert, Mountain and Water. A tile can contain a structure - either a shack or a standing stone - and that structure has a color (blue, green, white, black). There are also some areas of 2-3 connected tiles that contain an animal territory, indicated by a dashed border. The animals are bears and cougars.<\/p>\n

During each of your turns, you either guess at a location - in which case, each player in order will tell whether or not you are correct - or question another player to see if a certain location is allowed by their hint.<\/p>\n

 <\/p>\n

 <\/p>\n<\/div><\/div>

Reinforcement learning<\/h3>\n<\/div><\/div>

Reinforcement learning is a Machine Learning algorithm in which an agent will \"Learn\" how to properly navigate a problem by exploring and taking that feedback, building \"knowledge\" about the problem and using that to find an optimal course.<\/p>\n

I won't go into too much detail, but we'll be trying to use \"Episodal\u00a0 Q-learning\"<\/em>. The name of this technique is about the way we acquire knowledge, which is represented by the \"Q matrix\" and the algorithm is about the rules of putting the knowledge in. In our problem the algorithm is rewarded for winning the game (a game is an episode) and punished for game length and losing the game.\u00a0<\/p>\n

We'll also have a policy, a way of using knowledge to pick our move, that has a random component. In this case, either explore or pick one of the\u00a0top ten<\/em> moves. Not picking \"the best\" move allows tuning our future bots to different levels (easy, hard), if we ever want to use them like that.<\/p>\n

 <\/p>\n

 <\/p>\n<\/div><\/div>

Generating basic functionality<\/h2>\n<\/div><\/div>

The first feature I wanted to look into was Cursor using a library of sorts. I know that I'm going to use logic around a hexagonal grid, so I can generate some basic functions around that. Some of the functions gave me some trouble - it would generate deeply nested loops. I found that very specific instructions were required, like \"write a function that does X\" and then \"write a function that does Y using the previous function for X\".<\/p>\n

The game wants you to find objects within distance X. So, a useful function would be that when you have an attribute on a node, you can spread \"my neighbor has this\" to adjacent\/connected nodes. In this case, I want to be able to spread the attribute\u00a0forest=True<\/em> to each neighbor. The node itself and its neighbors shall have\u00a0neighbor_forest=True<\/em> and their neighbors will have\u00a0neighbor_neighbor_forest=True<\/em>, etc. But I don't want to nest a bunch of functions, so just first update neighbors and then see what nodes have neighbors with neighbor_forest<\/em>, right?<\/p>\n

It worked out pretty well (graph_utils.py<\/a>):<\/p>\n

 <\/p>\n

 <\/p>\n<\/div><\/div>

\ndef update_neighbors_with_prefix(\n    graph: nx.Graph, attr: str, prefix: str, levels: int = 3\n) -> None:\n    \"\"\"\n    Update nodes with prefixed attributes based on the presence of the attribute in neighboring nodes.\n\n    Parameters:\n    - graph: A networkx graph (nx.Graph)\n    - attr: The attribute to check for\n    - prefix: The prefix for the new attribute\n    - levels: The number of levels to check (default is 3)\n    \"\"\"\n    for level in range(1, levels + 1):\n        current_neighbor = \"_\".join([prefix] * (level - 1))\n        current_attr = f\"{current_neighbor}_{attr}\" if level > 1 else attr\n        new_attr = f\"{'_'.join([prefix] * level)}_{attr}\"\n        updates = {}\n        for node in graph.nodes:\n            # Check if the current node or any of its neighbors have the attribute set to True\n            has_attr = graph.nodes[node].get(current_attr, False) or any(\n                graph.nodes[neighbor].get(current_attr, False)\n                for neighbor in graph.neighbors(node)\n            )\n            updates[node] = {new_attr: has_attr}\n\n        nx.set_node_attributes(graph, updates)\n\n\ndef enrich_node_attributes(graph: nx.Graph) -> nx.Graph:\n    \"\"\"\n    Enriches the graph by adding attributes to each node indicating whether\n    the node or its neighbors (up to 3 levels) have a certain boolean attribute set to True.\n\n    Parameters:\n    - graph: A networkx graph (nx.Graph) with boolean attributes on nodes (one-hot encoded).\n\n    Returns:\n    - The enriched networkx graph with additional attributes.\n    \"\"\"\n    # Identify boolean attributes\n    boolean_attributes = set()\n    for node, attrs in graph.nodes(data=True):\n        boolean_attributes.update(\n            attr for attr, value in attrs.items() if isinstance(value, bool)\n        )\n\n    # Update attributes for all levels\n    for attr in boolean_attributes:\n        update_neighbors_with_prefix(graph, attr, \"neighbor\", levels=3)\n\n    return graph\n    <\/pre><\/div><\/div>
Basic tests<\/h2>\n<\/div><\/div>
So now we want to create a test suite for the same functions we generated. I simply created a new file, opened up ctrl+k for inline edits and used the prompt \"Use @graph_utils.py and generate unit tests for each function in it\", generating the unit tests for me.<\/p>\n
For example, we tested the upper function (test_graph_utils.py<\/a>):<\/p>\n<\/div><\/div>
\n  def test_enrich_node_attributes(self):\n        enriched_graph = enrich_node_attributes(self.graph)\n        for node in enriched_graph.nodes:\n            attrs = enriched_graph.nodes[node]\n            self.assertTrue(\n                any(\n                    attrs[f\"neighbor_is_{terrain}\"]\n                    for terrain in [\"swamp\", \"forest\", \"water\", \"mountain\", \"desert\"]\n                )\n            )\n          <\/pre><\/div><\/div>
What I found is that the testing isn't exhaustive, and if you want to add more test cases and particularly edge cases you will need to be explicit.<\/p>\n<\/div><\/div>
The Game<\/h2>\n<\/div><\/div>
Generating random terrain types and structures for different nodes was easy enough. The first really interesting function was creating animal territories. These need to be connected territories of 2-3 tiles. Cursor solved it readily (graph_generate_random_area.py<\/a>):<\/p>\n<\/div><\/div>
\ndef add_connected_area_attribute(G: nx.Graph, attribute: str, N: int) -> None:\n    \"\"\"\n    Orchestrates the process of adding an attribute to a random hexagon node and generating\n    a connected area of N nodes with the given attribute set to True.\n\n    Parameters:\n    - G: The networkx graph (nx.Graph) representing the hexagonal grid.\n    - attribute: The name of the attribute to be added.\n    - N: The size of the connected area to be created.\n    \"\"\"\n    if N > len(G.nodes):\n        raise ValueError(\n            \"N cannot be greater than the total number of nodes in the graph.\"\n        )\n\n    initialize_node_attributes(G, attribute)\n    start_node = select_random_start_node(G)\n    connected_area = expand_connected_area(G, start_node, N)\n    assign_attribute_to_nodes(G, connected_area, attribute)\n    def select_random_start_node(G: nx.Graph) -> int:\n    \"\"\"\n    Select a random starting node from the graph.\n\n    Parameters:\n    - G: The networkx graph (nx.Graph).\n\n    Returns:\n    - A randomly selected node.\n    \"\"\"\n    return random.choice(list(G.nodes))\n\n\ndef expand_connected_area(G: nx.Graph, start_node: int, N: int) -> set:\n    \"\"\"\n    Expand from the start node to create a connected area of N nodes.\n\n    Parameters:\n    - G: The networkx graph (nx.Graph).\n    - start_node: The node from which to start the expansion.\n    - N: The desired size of the connected area.\n\n    Returns:\n    - A set of nodes that form the connected area.\n    \"\"\"\n    visited = set()\n    queue = [start_node]\n\n    while queue and len(visited) < N:\n        current_node = queue.pop(0)  # BFS: FIFO\n        if current_node not in visited:\n            visited.add(current_node)\n            neighbors = list(G.neighbors(current_node))\n            random.shuffle(neighbors)  # Shuffle to ensure randomness\n            queue.extend(neighbors)\n\n    return visited\n<\/pre><\/div><\/div>
With the map now in place, I figured I was ready to create a \"solver\" - having perfect knowledge of each player's hint, where is the solution?<\/p>\n
The way the hint structure was setup, each player has a tuple with attributes that should be true on the node. It was straightforward to solve (game_rules.py<\/a>):<\/p>\n<\/div><\/div>
\ndef hint_applies(G, node, hint):\n    for attribute in hint:\n        if G.nodes[node].get(attribute, False):\n            return True\n    return False\n\n\ndef count_tiles_fitting_hints(G, hints):\n    count = 0\n    fitting_nodes = []\n    for node in G.nodes():\n        if all(hint_applies(G, node, hint) for hint in hints):\n            count += 1\n            fitting_nodes.append(node)\n    return count, fitting_nodes\n\n<\/pre><\/div><\/div><\/div><\/div>
\"Image<\/span><\/div><\/div>
But something didn't quite check out. I started evaluation by hand and quickly found that the proposed solutions were wrong.\u00a0<\/p>\n
I instructed cursor to visualize the map, and add some extra elements. First, I had it place game tiles to visualize the adjacency logic. Around a certain color structure, if neighbor_structure<\/em> is true, add all game pieces. For neighbor_neighbor_structure<\/em>, add all but one, etc.<\/p>\n
The pattern originally laid out didn't make sense. So I prompted to pick some random nodes and draw a line to their neighbors - aha! One of the basic functions, generate_hexagonal_grid<\/em>, had the adjacency wrong! It took some specific prompting to get it right. Now, at the start of every episode, I generate the image to the left so that I can sanity check the map.\u00a0<\/p>\n<\/div><\/div><\/div><\/div>
I'm not going to run you through all the code, but here's a short list of highlights:<\/p>\n