Working with AI: The Most Advanced Programming Language Yet?

Artificial intelligence has become one of those subjects that is difficult to discuss without encountering either exaggerated enthusiasm or outright hostility. Depending on which article you read, AI is either about to replace entire professions or is little more than an overhyped autocomplete system.

After spending several months using AI to help build the Jersey News Aggregator, the wider Auspice Darer publishing platform, and various supporting tools, my own view is somewhat different.

I have come to regard AI as something closer to a very advanced programming language.

That may sound like an unusual comparison, but it helps explain both its strengths and its limitations.

Programming Through Abstraction

The history of computing is largely the history of abstraction.

Early programmers worked directly with machine code. Later they used assembly language. Then came higher-level languages such as C, Pascal, PHP and Python. Frameworks and libraries followed, allowing developers to express increasingly complex ideas with increasingly simple instructions.

At each stage, programmers became less concerned with the precise details of how a machine performed a task and more concerned with what they wanted the machine to achieve.

AI feels like the next step in that process.

Instead of writing detailed instructions in PHP, I can describe a goal in plain English and receive a working implementation that can then be refined, tested and improved.

The machine is still executing code. The difference is that the language used to express the requirements has become much closer to natural human communication.

The Human Still Defines the Goal

One misconception about AI-assisted development is that the AI somehow takes ownership of the project.

That was certainly not my experience.

The AI did not decide to build a Jersey-focused news aggregator.

It did not decide to create a government reports archive.

It did not decide to build an online publishing platform or experiment with long-form fiction readers.

Those ideas originated elsewhere.

Throughout the project, the human role remained remarkably consistent.

Someone still needed to define the objective, understand the problem, prioritise features and decide what should be built next.

In practice, development often looked like this:

1. Define a goal.

2. Break the goal into smaller tasks.

3. Use AI to assist with implementation.

4. Test the result.

5. Refine the solution.

6. Repeat.

The AI assisted with the construction of individual components, but the overall direction remained a human responsibility.

Accelerating Development

The most obvious advantage was speed.

As someone with relatively limited experience writing PHP, I could certainly have learned many of the techniques used throughout the project.

Given enough time, I could have searched documentation, studied examples and assembled working solutions.

The AI dramatically reduced that process.

Tasks that might once have required hours of research could often be implemented and tested within minutes.

This did not eliminate the need to understand what the code was doing. In fact, understanding remained essential.

What changed was the speed at which ideas could be transformed into working prototypes.

The result was not merely faster coding. It was faster experimentation.

Encouraging Smaller Steps

One unexpected benefit was the AI's tendency to encourage incremental development.

When faced with a large problem, it often suggested creating a simple proof of concept before attempting a complete solution.

Rather than immediately building an entire feature, it might recommend:

• Testing the database connection.

• Verifying data collection.

• Confirming output formatting.

• Checking search results.

• Validating pagination.

This approach mirrors good software engineering practice.

By breaking large tasks into smaller testable components, problems could often be identified before they became difficult to diagnose.

In many cases the AI acted less like a code generator and more like a patient technical mentor encouraging a methodical approach.

Learning from Collective Experience

Perhaps the most valuable contribution was not the code itself but the ideas.

AI systems have been trained on enormous quantities of technical material. As a result, they often suggest approaches that have proven useful in other projects.

During development, the AI introduced concepts that I might not have considered immediately:

• XML sitemaps.

• robots.txt optimisation.

• Shared stylesheet architectures.

• Caching strategies.

• Search improvements.

• Archive structures.

• Automation techniques.

Most of these ideas were not revolutionary. They were established practices that had emerged because they worked.

What the AI provided was access to that accumulated experience without requiring me to discover each idea independently.

The Importance of Human Experience

At the same time, there were many occasions when experience with the project itself proved more valuable than technical analysis.

One recurring example involved website caching.

When a change failed to appear as expected, the AI would often consider a wide range of possible explanations.

Meanwhile, my instinct was frequently much simpler.

"Flush the cache."

More often than not, that turned out to be the correct answer.

The reason was straightforward.

I possessed something the AI did not: a history with the project.

The AI could analyse the current situation.

I could remember previous situations.

Those are different skills.

The longer a project continues, the more valuable that accumulated experience becomes.

Not All Ideas Came from the AI

It would also be inaccurate to suggest that every useful idea originated from the machine.

Many concepts emerged from my own observations and objectives.

The AI could suggest solutions.

It could not determine what I wanted the website to become.

In fact, some of the most useful developments arose through conversation.

An idea from one side would prompt a refinement from the other. A suggested implementation would reveal a new opportunity. A new requirement would inspire a different design.

The final result was often something neither participant would have produced independently.

Collaboration Rather Than Replacement

Looking back, I do not think AI replaced any part of the development process.

Instead, it changed the balance of effort.

Less time was spent searching for syntax.

Less time was spent hunting through documentation.

Less time was spent building routine components from scratch.

More time was spent thinking about goals, evaluating alternatives and refining designs.

The technology was valuable not because it removed the human from the process but because it allowed the human to focus on higher-level decisions.

Final Thoughts

The more I worked with AI, the less it resembled an artificial mind and the more it resembled a new layer of abstraction.

Just as earlier generations moved from machine code to assembly language and from assembly language to modern programming languages, AI appears to represent another step in the process of translating human intent into machine action.

The human still defines the destination.

The human still decides what is worth building.

The human still provides context, memory and judgement.

What AI offers is the ability to move from idea to implementation more rapidly than was previously possible, while simultaneously exposing the developer to a vast range of techniques and experiences drawn from countless other projects.

If that makes AI a programming language, it is certainly the most interesting one I have used so far.