Can Large Language Models Really Boost Programming Productivity? Insights from Redis Founder

The Redis founder antirez wrote his first 2024 blog post, sharing his personal impressions of large language models (LLMs) from a programmer’s perspective, noting that while Google search has become a sea of junk, current AIGC is "stupid yet all‑knowing".

He argues that LLMs currently make strong programmers even stronger, as most coding tasks are repetitive and do not require deep reasoning; LLMs excel at "throw‑away" programs. The author translated and trimmed the original post without altering its intent.

Since ChatGPT’s emergence, generative AI has seen widespread use. The author seeks to leverage LLMs to improve coding ability and free valuable time from low‑value tasks, criticizing the difficulty of finding useful content in today’s search engines.

Although not a coding novice, the author increasingly relies on LLMs for advanced code, especially Python, less so for C.

He observes that LLMs are useful when the user knows when to apply them; blind use can slow progress. For disciplined users, LLMs act like a powerful encyclopedia or video tutorial, but for less capable users the marginal benefit drops sharply.

Large Language Models: Omniscient or Parrot?

The AI community still has limited understanding of LLMs. While neural networks can be trained on massive data, they remain opaque, and their reasoning abilities are modest.

Some underestimate LLMs as mere advanced Markov chains, but evidence shows they go beyond simple parroting.

Others overestimate them, believing they possess supernatural powers; in reality, LLMs interpolate within the data space they were trained on, which can still surprise humans but remains bounded.

In practice, developers still have room to thrive. LLMs can generate code they have never seen and show early signs of guiding development direction, yet they fail catastrophically on subtle reasoning tasks.

Stupid Yet All‑Knowing

LLMs perform basic, often inaccurate reasoning and can hallucinate, but they possess vast knowledge.

In programming, they act like a foolish scholar: they propose absurd ideas, requiring the developer to steer the solution.

If treated as a tool for inspiration, they can quickly move a user from ignorance to a self‑learning state.

Historically, programmers needed only a few languages and libraries; today’s ecosystem has exploded, making LLMs a valuable guide.

Example: the author switched from Keras to PyTorch and used an LLM to generate Torch code once the model idea was clear.

Case Studies

LLMs excel beyond simple queries like "How to implement X?" and can handle complex tasks that were unimaginable a few years ago.

For instance, the author asked GPT‑4 to rewrite a PyTorch neural network to adjust tensor sizes, receiving functional code that he then verified.

Another example involved creating a BLE client for ESP32 using Objective‑C; with LLM assistance, the author completed the project in a short time despite a decade‑long gap in Objective‑C experience.

These LLM‑generated snippets, though not always elegant, dramatically accelerated development.

Throw‑Away Programs

The author frequently uses LLMs to generate quick scripts, such as visualizing loss curves from CSV files or aggregating Airbnb data, achieving results in seconds.

He believes LLMs interpolate between training examples rather than merely copying, enabling them to adapt to novel requirements.

LLMs Struggle with System Programming

When attempting to generate a Bloom filter in C, the LLM produced sub‑optimal code and lacked the deep reasoning needed for robust system‑level implementations.

Even with large models like GPT‑4, the author finds that system‑programming tasks often exceed LLM capabilities, though they can still assist with documentation and code explanation.

Smaller models perform worse; larger models (e.g., Mixtral, DeepSeek‑Coder) show noticeable improvements but still fall short of expert reasoning.

Proper Perspective on LLMs

Most coding work today is repetitive and suits LLM assistance, yet the hard limits of context size remain.

Programmers should consider whether writing certain code is worth the effort, as LLMs may soon automate many such tasks, potentially displacing some developers within a decade.

The author believes LLMs possess a nascent form of reasoning, blending learned patterns into abstract models, though still fragile.

He encourages developers to embrace LLMs, craft precise prompts, and use them as a core development skill, while also recognizing that communication abilities often limit programmers more than technical knowledge.

Reference: http://antirez.com/news/140