Do More with Less: The LLM Era's Challenge to Software Development and Leadership

Recently, I faced a mountain of data spanning months, coming from multiple sources. Normally, this would mean hours—or even days—of writing code, transforming datasets, and checking for errors. But this time felt different.

In about one hour, I extracted, transformed, and compared the data, uncovering interesting patterns—all without writing a single line of code. Instead, I spent my time instructing AI on what to do and validating its outputs. I was deeply involved, but not in the traditional "hands-on coding" sense. I was collaborating with a tool that could think, reason, and execute, and it allowed me to focus on problem-solving rather than boilerplate work.

Research indicates a similar pattern: developers can save up to 40% of their time on repetitive tasks using AI, while critical decisions still require human judgment. This experience reshaped my understanding of what it means to do more with less: not replacing humans, but amplifying our capability to deliver, innovate, and reflect.

The Questions We All Ask

Over the past few years, while working in the digital world, I've noticed a pattern that really captures the challenges and uncertainties of today's software development landscape. Whether in meetings, interviews, or casual conversations with colleagues and students, the same questions keep coming up:

What does the future hold for us in the age of AI?
Will traditional, manual software development still matter?
Will AI take over our jobs—or simply help us get more done?
What does doing more with less really mean?

These aren't just abstract questions—they're real concerns we face every day, influencing how we work, learn, and lead in technology. In Germany, 16% of workers fear AI could take their job, and almost 30% believe AI will make many roles redundant, even though overall employment remains stable.

The Pressure on Teams and Leaders

Stepping into leadership, I quickly realized that the challenges went far beyond individual productivity. It wasn't just about writing code or meeting deadlines—it was about how teams could adapt, evolve, and perform in an AI-driven environment.

With leaner staffing, higher expectations for rapid delivery, and growing reliance on AI tools, we faced the challenge of maintaining quality, building resilience, and determining which tasks must remain human versus which could be automated.

As AI became integral to workflows, deeper questions arose:

How small can teams get as AI takes on more tasks?
Which responsibilities must remain fundamentally human?
Where should we draw the line between automation and judgment?

These concerns are widespread: almost 65% of engineering leaders are uncertain how AI will affect team size and structure over the next two to three years, while over 50% of CTOs lack a clear model for what an "AI-augmented team" should look like.

Against this backdrop of uncertainty, industry leaders are calling for a deeper, more strategic role for AI:

Sam Altman (OpenAI): Engineers can achieve far more by integrating AI into their workflows.
Dario Amodei (Anthropic): AI should handle routine coding, freeing humans for design, strategy, and complex problem solving.
Andy Jassy (Amazon): AI can transform how roles are executed, enabling teams to focus on higher-value work.
Marc Benioff (Salesforce): AI is shifting support functions, allowing humans to focus on nuanced and impactful tasks.
Mark Cuban encourages developers to join teams where AI is deeply embedded, amplifying individual contribution and impact.

AI as a Partner, Not a Replacement

With the theoretical context in place, I want to share my own practical experience. Over the past few years, I've worked closely with AI across the software development lifecycle—writing code, debugging, testing, and producing documentation. I began with ChatGPT and gradually integrated GitHub Copilot into my daily workflow.

The impact has been undeniable. MVPs that once took me days to build can now come together in a matter of hours. At the same time, the journey hasn't been frictionless. I've spent considerable time refining prompts, providing clearer context, and navigating unexpected behavior—such as Copilot modifying my README when I was simply seeking guidance. These moments of frustration are part of the reality of working with AI, and they often demand time and attention that could otherwise be spent on production or creative problem-solving.

Redefining Roles in the AI Era

By now, it is clear that AI is here to stay—and it continues to grow more powerful. Large language models such as GPT-4 Turbo, Claude 3.5, and the latest GPT-5 function as genuine partners in problem-solving. Working with these tools has shifted the way we approach software development: it's no longer just about writing lines of code. Instead, the measure of progress lies in how effectively we guide, evaluate, correct, and integrate AI-generated outputs to achieve meaningful results.

From my experience, operating in an AI-augmented development landscape means wearing multiple hats simultaneously:

Developers: We define intent, constraints, and direction for LLMs. This requires not just coding skills, but also the ability to communicate requirements clearly to AI systems to get meaningful results.
Reviewers: We validate correctness, security, maintainability, and scalability. We should spend time catching subtle errors, anticipating vulnerabilities, and ensuring outputs meet best practices.
Architects: We make sure AI-assisted solutions align with long-term system design. This involves making high-level decisions about design patterns, system cohesion, and maintainability.
Owners: We remain accountable for outcomes produced with AI assistance, including project success, quality standards, and timely delivery.
Learners and Innovators: We should use AI as an augmented partner to explore new skills, experiment with tools, and find innovative ways of working. This includes refining prompts, asking better questions, and creatively integrating AI outputs into projects.

When examining industry trends, the impact of AI on developer roles is becoming increasingly evident: 65% of senior developers expect their roles to be redefined by AI by 2026, reflecting widespread uncertainty about job boundaries and responsibilities. Meanwhile, around 59% anticipate the emergence of new, more specialized roles, highlighting not only AI adoption but also the ambiguity surrounding what these roles will involve.

In short, AI will not replace our roles—it will expand them, demanding adaptability, judgment, and creativity while enabling us to focus on higher-value problem-solving and strategic decision-making.

The Risks of AI in Practice

While LLMs can significantly boost productivity, they also introduce new risks. From my experience, probabilistic outputs, hidden defects, and subtle security vulnerabilities make human judgment essential. According to the 2025 Stack Overflow Developer Survey, only 33% of developers trust the accuracy of AI outputs, while 46% actively distrust them, even as adoption continues to rise. This highlights why AI-generated code cannot be taken at face value—we must actively transform probabilistic outputs into reliable, deterministic solutions and enforce proper guardrails.

Balancing the pursuit of efficiency with rigorous engineering discipline is crucial. Even as AI handles repetitive or large-scale tasks, maintaining a deep understanding of code, systems, and design principles ensures we do not become overly dependent on automation. In my work, this careful balance has been key to sustaining both speed and long-term software quality.

Partnering with AI: My Approach to Collaborative Development

Over the years, I've learned that working with AI isn't a one-size-fits-all process. The approach I take depends on the task, the desired outcome, and the level of control required. Surveys show that 84% of developers now use or plan to use AI tools in their workflow, with 51% relying on them daily—yet trust remains a challenge, as only 33% trust AI outputs and 46% actively distrust them as discussed.

One approach I often use is letting AI take the lead, which is agentic engineering. In this workflow, the AI acts like an independent teammate: I provide a prompt, and it plans steps, interacts with code repositories, runs tests, and iterates toward solutions. This method is particularly effective for repetitive or large-scale tasks, a trend supported by industry data showing that agentic AI tools can boost productivity by 10–30% on average. From my experience, it is highly efficient, though it can occasionally be unpredictable or repeat work, making careful oversight essential.

Another approach keeps me closely involved, which is agentless workflows. Here, I maintain full control, breaking tasks into smaller parts and using AI to suggest edits, fix issues, or generate solutions in a structured manner. For example, I might start by reviewing entire files, then focus on specific sections or functions, and finally evaluate the AI's recommendations. Regression and validation tests help ensure the most reliable outcome. This method is slower and demands more expertise, but it guarantees accuracy, quality, and full human oversight—especially important since many developers report spending significant time fixing "almost right" AI-generated code.

Most of the time, I adopt a hybrid approach—allowing AI to explore ideas and handle repetitive work while I step in to review, refine, and make final decisions. In my experience, this collaborative method has been transformative: it maximizes productivity without compromising quality, control, or reliability, enabling outcomes that neither AI nor humans could achieve alone.

One of the most remarkable outcomes I've experienced with AI-assisted development is the ability to maintain work-life balance and stay motivated. By offloading repetitive, time-consuming, and mundane tasks to AI, I can dedicate my energy to creative problem solving, uncovering hidden opportunities, and exploring futuristic possibilities. This shift not only keeps me productive but also fosters a healthy and happy mindset.

Doing More with Less in Practice

As mentioned earlier, doing more with less is about unlocking the next frontier of human potential. AI is redefining development excellence—accelerating delivery while preserving critical thinking, deep technical mastery, and long-term software sustainability. The future belongs to those who collaborate seamlessly with AI, guiding, evaluating, correcting, and integrating its outputs to achieve unprecedented productivity and quality.

Achieving this often comes down to strategically using both agentic and agentless approaches as discussed. Agentic tools rapidly generate and test solutions, while agentless methods handle fine-grained validation, patching, and decision-making.

Embedding this mindset into a team's culture is equally important. From my experience, successful cultural adaptation balances short-term gains with long-term sustainability, ensuring teams remain productive, capable, and resilient over time.

Promoting a Culture of Doing More with Less

Fostering a culture that truly embraces doing more with less—as discussed earlier—is essential. Here are some guiding principles:

Efficiency Must Complement Understanding: "Doing more with less" means using AI to amplify human thinking, not replace it. Agentless or hierarchical approaches help retain control, interpretability, and insight, even as AI handles repetitive tasks.
Growing People, Not Replacing Them: Achieving "doing more with less" requires developing human skills, not creating passive "prompt engineers." Engaging with agentless workflows keeps logic, testing, and reasoning sharp—crucial for long-term growth.
Balancing Short-Term Productivity with Long-Term Quality: True "doing more with less" isn't just about speed. Sustainable, maintainable systems need humans who can reason about trade-offs, security, and architecture.

The culture of software development is evolving—not because AI writes code, but because AI reshapes what we value and how we work. The future belongs to those who embrace "doing more with less" by harnessing AI's strengths while retaining judgment, strategy, and human agency.

The Future is in Our Hands

AI is reshaping software development not by replacing humans, but by redefining what excellence looks like in our profession. "Doing more with less" is no longer about cutting effort or headcount—it is about augmenting human capability through AI, while preserving clarity of thought, deep technical understanding, and professional judgment.

For developers, this means moving beyond writing code to mastering intent, evaluation, and accountability for AI-assisted outcomes.

For leaders, it requires designing teams, processes, and cultures where AI amplifies productivity without compromising quality, resilience, or trust.

For educators, it demands preparing the next generation not just to use AI tools, but to reason, question, and think critically alongside them.

In this new era, AI literacy combined with human judgment becomes the professional baseline. Those who embrace this balance—leveraging AI's speed while retaining ownership, strategy, and ethical responsibility—will shape the future of software development. The tools may evolve rapidly, but the future remains firmly in human hands.