AI in Coding, Part 1: From Lisp to Copilot – The Evolution of AI in Software Development

Artificial Intelligence feels like a new revolution, but the story of AI in coding started decades ago. By understanding where we came from, we can better see where we are today, and where the road might lead.

Early Days: Expert Systems and Symbolic AI

In the 1960s and 70s, AI was built on rules and logic. Languages like Lisp (1958) and Prolog (1972) were created to let researchers model reasoning and problem solving.

One famous program from this era was SHRDLU, built in 1970. It could manipulate blocks in a virtual world and respond to natural language commands like “pick up the red block”. Another milestone was Mycin (1972), an expert system for diagnosing infections. Mycin wasn’t perfect, but it showed how AI could take a knowledge base and apply it to solve practical problems.

These systems didn’t learn from data. Instead, humans manually coded the rules. That worked in narrow domains but struggled with the messiness of the real world.

The Machine Learning Revolution

In the 1990s and 2000s, AI shifted toward statistical learning. Instead of rules, systems learned from data. This is when algorithms like Support Vector Machines (SVMs) and decision trees became popular.

A few famous milestones:

Deep Blue beating Garry Kasparov at chess (1997) showed machines could surpass humans in structured games.

IBM Watson winning Jeopardy! (2011) showcased natural language processing at scale.

In software development, this era brought smarter autocomplete in IDEs and better bug detection tools. Nothing like Copilot yet, but the idea of AI assisting developers was seeded here.

The Rise of LLMs and Transformers

Everything changed with the Transformer architecture introduced by Google in 2017 in the paper “Attention Is All You Need.” Transformers made it possible to train models on massive amounts of text with incredible accuracy.

This led to the explosion of large language models (LLMs) like BERT (2018), GPT-2 (2019), and GPT-3 (2020). Suddenly, natural language processing was no longer just for chatbots and search. It could generate code, explain concepts, and translate natural language into functioning programs.

Codex, Copilot, and AI in Everyday Coding

The leap from GPT-3 to Codex (2021) was a turning point. Codex was trained specifically on code, making it far better at generating working software. GitHub Copilot, powered by Codex, quickly became the first mainstream AI pair programmer.

Developers could type a comment and get full functions suggested. Instead of writing boilerplate by hand, Copilot handled it. Productivity rose, and adoption spread fast.

By 2023, tools like Cursor IDE and Replit Ghostwriter emerged, making AI an integral part of the editor. In 2024 and 2025, the conversation shifted from simple autocompletion to AI agents that could open pull requests, fix bugs, and even run automated tests in sandbox environments.

Why This History Matters

History shows us a pattern:

Rules-based AI (1960s–1980s) gave us structure but lacked flexibility.

Machine learning (1990s–2010s) gave us adaptability but required heavy data and manual oversight.

LLMs and coding-specific AI (2020s) gave us fluency, creativity, and a new way to collaborate with machines.

Each leap didn’t erase the previous one, it layered on top of it. Today’s AI coding tools are built on decades of experimentation, research, and incremental breakthroughs.

And this matters because it reminds us: the current wave is not the end of the story, just the latest chapter.

✅ Key Takeaway

AI in coding didn’t appear overnight. From Lisp to Copilot, it has been a steady march toward making machines collaborators rather than just tools. Understanding this trajectory helps us predict what might come next.

This article is part of my series “AI in Coding – From Past to Future.”

🎥 Watch the Full Lecture

For a deeper dive into this topic, watch my complete presentation on AI in software development:

Note: The introduction is in Bosnian, but the main lecture is in English and starts around the 3-minute mark.

This lecture covers all the topics in this series and provides additional insights and Q&A.

Full Series:

• Part 1: From Lisp to Copilot: The Evolution of AI in Software Development (this post)
• Part 2: AI Tools Every Engineer Should Know in 2025 (Coming October 2)
• Part 3: Best Practices for Working with Your New Junior Developer (Coming October 6)
• Part 4: I Let AI Build BigToFit.com During My Lecture (Coming October 9)
• Part 5: How Far We’ve Come in Just 3 Years (Coming October 13)
• Part 6: The Next 10 Years of Software Development (Coming October 16)
• Part 7: Will AI Replace Programmers? (Coming October 20)
• Part 8: Future-Proofing Your Career (Coming October 23)

What’s your experience with AI coding tools? Have you seen the evolution from basic autocomplete to today’s AI assistants? I’d love to hear your thoughts on how far we’ve come.