As AI models become more powerful, I’ve heard speculation that AI will soon replace frontend web developers. I don’t think this will be the case.

Currently, I don’t use AI at all for development, and think it should be completely avoided for frontend development.  Humans have a fundamental advantage when it comes to understanding how to build a website that fits the preferences of user. This advantage wouldn’t go away, even if we could magically conjure up an AI model that cost nothing to train or run. 

When developing a website, you are making something that users will look at and interact with  People have a variety of preferences for their user experience that can’t be precisely encoded in data, while an AI model needs data. There might also be specific circumstances that affect use of a website such as a college student spending less time on an online game site during final exam week. 

A human developer can talk to likely users to get an understanding of their preferences and circumstances. The developer can then understand how those circumstances will affect someone’s usage of a site and then incorporate that understanding when working on a site.

I’m currently working on developing event RSVP functionality for dmvboardgames.com. Initially, I decided to have separate database tables for users with edit permissions on an event and people who have an RSVP to attend an event.

However, I ran into challenges because of the need to query both tables to display information about an event. Event hosts should have permission to edit an event, and they should also be automatically counted as an event RSVP. Also, event hosts should not have the ability to directly update their RSVP like a regular user, and they should have another UI to step down as event host or make someone else the host.

To simplify the code and the database, I decided to combine event rsvp and event editor permissions into one table. After updating the schema on my local environment, I ran the integration tests, which unsurprisingly had test failures. Within approximately 15 seconds, the test results identified which areas of the code needed to be updated. This will be especially useful for developers who haven’t been closely working with the codebase for months.

I also added a test case to verify that a standard user could not modify an event. Then I set the test to automatically fail as a placeholder until I created the test. This was a reminder that this test had to be run before a production deployment. When attempting to create a build for a production deployment, the build will fail if there are any test failures.

After updating queries and deleting some code, the tests passed. Aside from simplifying the code and database design, the performance was better because I was able to get rid of an extra database query when retrieving event RSVP data.

On the other hand, I maintain a copy of the database schema definition for the unit tests that is not automatically synced with the database migrations that were run in production. There are a large number of migrations that have run, and some of them involve schema changes to existing tables. Running these migrations to set up a test database would make the tests take significantly longer to finish. Each test file recreates the database schema and test data to help ensure that tests aren’t affected by other tests. Manually copying the relevant schema changes is also less complex than an automated copying process.

Also, the local development environment uses the same copy of the database schema definition. This allows for manual testing to help verify that the test schema is in sync with the production schema.

http://vanilla-js.com/

I think AI is useful for specific tasks with inputs and outputs that can be represented as data. That being said, I there are two fundamental problems that make LLMs unsuitable for work outside the costs of creating or running them. First. most tasks cannot be represented by data. Second, LLMs will generate plausible sounding output about things they don’t understand, which makes it hard to tell when using an LLM is useful.

With a task specific AI for something such as spell check, there will be a clear boundary between what the AI can do and what it doesn’t understand. Trying to use a spell check AI for something such as writing legal briefs will result in output that is clearly unusable instead of something that appears to make sense.

This article gives a great overview of why using LLMs should not be used to write legal briefs.https://apnews.com/article/artificial-intelligence-tools-work-errors-skills-fddcd0a5c86c20a4748dc65ba38f77fa


Here are some great examples of task specific AI and when they were created.

Weather prediction(1950): https://www.vos.noaa.gov/MWL/dec_07/weatherprediction.shtml

Spell checker(1961): https://en.wikipedia.org/wiki/Spell_checker

Automated train operation on the DC Metro(1976): https://www.wmata.com/initiatives/plans/Automatic-Train-Operation-ATO/index.cfm

StarCraft:Brood War AI(1998): https://en.wikipedia.org/wiki/StarCraft:_Brood_War

TI-89 Titanium Integral Solver(2004): https://en.wikipedia.org/wiki/TI-89_series#TI-89_Titanium

I have a theory that LLMs have sections representing various areas of knowledge. They are trained to recursively split up input, send them to the relevant sub sections, and then logically connect them together at the end. Below are some thoughts explaining my logic behind the theory and some relevant research I found.

Until more conclusive research is found, this theory should be treated as speculation, and not an authoritative explanation of how LLMs represent knowledge. While I don’t plan to use LLMs for my work, I want to understand how they work.

Why this theory makes sense to me

Recently, I’ve noticed many people have found LLMs such as Anthropic Claude, ChatGPT, and Github Copilot to be helpful for their work. Output generated by these LLMs suggests that they have advanced beyond just memorizing outputs based on their inputs and have some sort of knowledge.

Trying to train a model to have knowledge by simply searching for points that are close to optimal or optimal is impractical with billions of dimensions. I also don’t think methods used to help train models such as gradient descent work with billions of dimensions. To me, it appears that LLMs use techniques to reduce the number of dimensions they are looking at when training..

If requests can be routed to different sections of the model based on their subject, that can be a way of reducing dimensions. For example, if there was a 100 million parameter model that was designed to answer history and math questions, the model could be effectively split into a 50 million parameter history submodel, and a 50 million parameter math submodel. These submodels could then be recursively split up into smaller submodels to reduce dimensions.

I was also thinking about how students learn in school. Students don’t learn calculus by looking at a bunch of questions, memorizing them, and then adapting them into actual knowledge. Learning a foreign language doesn’t mean memorizing translations, and then becoming a fluent speaker. Learning calculus means learning to recognize numbers as a young child, learning basic arithmetic, and then slowly learning more advanced math until you know enough to understand calculus. This is analogous to having submodels representing different areas of math and then logically connecting them together.

My Thoughts on using LLMs and relevance to this theory.

I think the productivity gains people are seeing from using LLMs is due to the fact that their costs are being subsidized. Once LLM owners stop subsidizing LLM costs, they will become too expensive to be useful for most people. One reason I don’t work with LLMs is because I don’t want to be dependent on them and suddenly have to pay more for them when prices increase. I also think it will be hard to avoid the temptation to use LLMs in places where they are ineffective due to inputs or outputs that can’t be quantitatively defined.

If LLMs are split up into smaller sections representing specific areas of knowledge, that also means that general purpose LLMs that are commonly used today aren’t the most efficient way of getting work done. It would then be better to have smaller, more specific models. Also, smaller specific models would help ensure that AI is used in areas where it is useful due to quantitatively defined inputs and outputs.

If the theory about LLMs consisting of smaller submodels is correct, this also means that the way they are trained could be improved. An task-specific LLM could be trained through multiple iterations with different sizes of data. The first training phase could be on training with small items of data representing simple concepts to build the small submodels. Afterwards, the models could then gradually increase the size of the data items used during subsequent training phases. This would help the model gradually build larger submodels that are logically linked together.

One practical use of this technique could be improving the accuracy of weather predictions. A model could be trained to understand to understand math using the multi stage training process described in the previous page. The model could be trained to understand basic laws of physics at a conceptual level such as gravity and momentum with the result going in a separate section of the model. Another section of the model could be trained to understand concepts relevant to weather such as the amount of sunlight that will reach an area based on the earths orbit and rotation around the sun. Then, there could be another training round that would make sure the submodels are logically combined.

Some relevant research I found

• https://arxiv.org/pdf/2412.19260v1

• Garcia, Mirian H., et al. “EXPLORING HOW LLMS CAPTURE AND REPRESENT DOMAIN-SPECIFIC KNOWLEDGE.” Arxiv, vol. 2504.1687, no. 2, 2025, pp. 1-21. Arxiv, https://arxiv.org/pdf/2504.16871.

  “ The hidden state traces in autoregressive models showed consistent clustering around domain-specific queries. When samples from the Specialized Pool were introduced, a clear separation between domain-related queries emerged, indicating that these models are capable of distinguishing between domain-related requests beyond simple semantic similarities.”

Recently, I came up with the idea of a hidden role game based on the idea of robotic toasters invading Earth. The idea was inspired by the Battlestar Galactica episode where the humans are trying to escape from a planet occupied by the Cylons.

A draft of the rules can be viewed here.

Game Rules