Many developers today have a rather short-sighted view of what an LLM — or even an AGI — will mean for the future. Most see these models merely as chatbots that help or advise, a sort of consultant or pair programmer. And yes, they do that perfectly, but at its core, it’s still just doing the same work as before — only with a helping hand. Essentially, an LLM generates code that accomplishes what you would have done without it, often in a more drawn-out process. This dynamic has fueled the perception (and myth) among those with less technical insight that LLMs — and future AGIs — will completely replace computer engineers.
“They will replace tasks — but only those performed by people who were never true engineers or who lack an engineering mindset.” 😊
Here’s the first dose of reality: Yes, LLMs will replace some tasks, but only those handled by individuals without a genuine engineering approach. Mindset and discipline matter. Formal studies are one systematic (albeit expensive) path to achieving that mindset, but they are not the only way.
“Development has never been about mere coding; it’s about engineering — applying science to solve real-world problems.”
Programming is just one tool in our toolbox — much like LLMs.
Imperative vs. Declarative Programming
We currently rely on imperative programming — issuing precise instructions because that’s what we have at hand. The problem? This approach is inherently inefficient. When the context changes, you must manually adapt the code, making systems fragile and costly to maintain.
“The main job of an engineer is to ask the right questions — a process not so different from crafting the perfect prompt.” 🤔
In an ideal world, we’d embrace declarative programming: instead of giving detailed instructions, you declare the problem correctly (by setting the right context) and define your expectations. If the context shifts, only the context or expected outcomes need to be updated — not the intricate details of the program.
This concept isn’t new. Prolog, for example, allowed you to provide context, turning programming into a process of asking questions. Later, with the advent of machine learning and neural networks, many believed programming would transform into feeding in training data and letting the network learn to solve problems. However, that approach struggled to scale — primarily due to high costs and significant hardware and time demands. (Well, maybe not as much anymore, thanks to advances in GPUs and projects like DeepSeek!)
Rethinking Programming in the Age of LLMs
Consider a simple task like parsing a PDF. You could ask an LLM to generate the code, but every time something changes, you’d need to request new code or manually tweak it. Instead, it makes far more sense to create an agent and instruct it to parse a PDF to yield the desired results.
However, a major challenge arises: LLM APIs are expensive. What happens if you need to perform many tasks or even nest agents within one another? This is where model distillation becomes crucial. For tasks that don’t require the full potential of a huge model, a distilled version can suffice.
For instance, consider that DeepSeek’s largest model boasts 671B parameters and requires at least two H100 GPUs to run reasonably (each costing around $30K USD). In contrast, a distilled 7B model can run on a laptop or a server equipped with an NVIDIA 3070 (8GB), and even a 1.5B model can function on a 3060 (12GB). It’s not exactly a bargain, but it’s far more accessible. The beauty of these distilled models is that, despite their reduced parameter count, they still scale impressively in performance.
“Deploy several local agents to handle simpler tasks — planning, reviewing results, refining prompts, perfecting context, cleaning up information, interacting with users, generating commands, etc. — while reserving the large API model for tasks that truly demand its full capability.” 😎
Embracing a New Era
The true advantage of LLMs lies in programming agents and declaring exactly what you need. Developers who master this approach will remain as indispensable as ever, if not more so. A person with an engineering mindset — one who isn’t solely focused on the technology itself — should have no trouble adapting. In fact, they should be excited about not having to waste time on repetitive, tedious tasks like code maintenance, exhaustive testing, or churning out boilerplate code that adds little value.
“The future isn’t about being replaced by LLMs; it’s about evolving our roles to focus on higher-level problem-solving and innovation.” 💡
Let’s embrace this change, refine our questions (or prompts), and continue building robust, efficient solutions for the real world.
Happy engineering!
Example: Chaining Local Agents for Complex Task Resolution
Imagine an e-commerce company that needs to transform thousands of scattered customer feedback entries into a comprehensive, actionable sentiment report. Here’s how a chain-of-agents approach can solve this real-world problem:
- User Input Agent Real-World Problem: Collecting Diverse Customer Feedback A lightweight local agent gathers raw input from multiple channels — emails, social media posts, and chat logs — from customers reporting issues like delayed shipments or product quality concerns.
“Accurate collection of diverse feedback is the cornerstone of any successful customer satisfaction analysis.” 📝
- Input Cleaning Agent Real-World Problem: Normalizing Unstructured Data Once collected, the data is messy — filled with typos, slang, or repetitive content. A cleaning local small agent processes this input by standardizing the text, removing duplicates, and filtering out irrelevant details. For example, it might correct misspelled product names or strip out unnecessary punctuation from the reviews, ensuring a uniform dataset for further analysis.
“Clean data leads to clear insights; it’s the first step toward effective problem-solving.” ✨
- Execution Plan Agent Real-World Problem: Identifying Key Themes The cleaned data is then analyzed by an execution plan local small agent that identifies critical topics such as “shipping delays,” “product defects,” and “customer service issues.” It generates a structured plan by segmenting the feedback into these categories and prioritizes tasks based on the frequency and severity of the issues.
“A well-defined plan is half the battle won.” 📊
- Prompt Generation and Routing Agent Real-World Problem: Efficient Task Delegation With a clear execution plan, another local small agent generates tailored prompts for each sub-task. This agent smartly decides which tasks are simple enough to be handled locally by a distilled model — such as basic sentiment analysis on straightforward feedback — and which ones require the advanced capabilities of a powerful API, like detecting sarcasm or nuanced sentiment in complex reviews.
“Smart routing saves both time and resources — use local agents when you can, and reserve the API for the heavy stuff.” ⚙️
- Complex Task Execution via API Real-World Problem: Advanced Natural Language Processing For tasks that exceed local capabilities, the system escalates to a high-powered API. For instance, analyzing intricate customer reviews that include subtle language cues and mixed sentiments is sent to the API. Once the complex analysis is complete, the results are integrated with locally processed data to produce a comprehensive, actionable customer sentiment report.
“By intelligently chaining agents, we optimize performance while keeping costs in check — harness the best of both worlds!” 🚀
- Aggregation and Report Generation Agent Real-World Problem: Consolidating Insights for Decision-Making With all processed data — categorized feedback, refined sentiments, and advanced analysis results — in hand, a final local agent aggregates this information. It compiles a comprehensive report that includes data visualizations, charts, and an executive summary. The report highlights key insights, emerging trends, and actionable recommendations for the e-commerce company to enhance their operations and customer satisfaction.
“The final report is where all insights converge, providing a clear roadmap for strategic decision-making.” 📈
Top comments (0)