Wednesday, June 11, 2025

Human Ingenuity in the Age of Generative AI

The Human Edge: Cultivating Enduring Engineering Virtues in the Age of Generative AI


As generative models automate the 'how,' our strategic value shifts to the 'why,' the 'what if,' and the 'should we.' It is time we recalibrate our definition of engineering excellence around a set of timeless virtues.

Abstract representation of human thought and AI
The symbiosis of human intuition and machine precision.

We stand at a fascinating inflection point in the history of technology. The discourse around Generative AI, particularly in software engineering, is saturated with notions of "10x productivity," "autonomous agents," and the automation of coding itself. These conversations are important, but they are dangerously incomplete. They focus almost exclusively on the tool, while neglecting the craftsman.

For decades, we have optimized our craft around the efficient translation of requirements into code. But what happens when that translation becomes trivial, a commodity service provided by a large language model? The answer is not that the software engineer becomes obsolete. The answer is that the very definition of an engineer's value undergoes a profound transformation. We must shift our focus from the ephemeral tactics of code generation to the enduring virtues of judgment, wisdom, and stewardship.

"We are what we repeatedly do. Excellence, then, is not an act, but a habit."
— Will Durant (interpreting Aristotle)

 

Drawing inspiration from Aristotelian philosophy, I propose we must intentionally cultivate four cardinal virtues for the AI-augmented engineer. These are not new skills, but rather timeless capabilities that are now thrust into the foreground as our true differentiators. They are the recipes for success, both in how we build our teams and how we operationalize our work.

The Four Virtues

I. Phronesis (Φρόνησις): Practical Wisdom & Critical Judgment

Aristotle defined phronesis as practical wisdom—the ability to discern the right course of action in complex, particular situations. In an age of AI, this is the paramount virtue. An LLM can generate a microservice architecture in seconds, but it lacks the wisdom to ask critical questions:

  • Is this architecture appropriate for our team's skill set and our operational maturity?
  • What are the second-order effects of this design on our data governance and security posture?
  • Does this technically elegant solution actually solve the user's underlying problem, or does it merely address the stated requirement?
  • How do we assess the quality, bias, and potential hallucinations in the AI's output?

Engineers demonstrating phronesis are not just prompt engineers; they are critical thinkers who treat AI as a brilliant but fallible junior partner. They are skeptics, validators, and contextualizers. They possess the wisdom to know when not to use AI.

II. Techne (Τέχνη): Systemic Craftsmanship & Architectural Integrity

Techne is the knowledge of how to make things, but it transcends mere technique. It is craftsmanship rooted in a deep understanding of principles. While AI can generate code snippets (the technique), it struggles with the holistic, systemic view required for robust, maintainable, and scalable systems.

The engineer strong in techne focuses on what the AI cannot see:

  • Non-Functional Requirements: Ensuring the generated code meets stringent requirements for performance, reliability, and observability.
  • Architectural Seams: Designing the clean interfaces and abstractions that allow AI-generated components to be integrated, tested, and replaced without compromising the integrity of the whole system.
  • Economic Viability: Understanding the cost implications (compute, API calls, maintenance) of an AI-proposed solution over its lifecycle.

They are the architects who ensure that the locally-optimized code produced by an AI contributes to a globally-sound and coherent system.

III. Arete (Ἀρετή): Excellence in Purpose & Communication

Arete means excellence or virtue, fulfilling one's purpose. For an engineer, this purpose is to solve human and business problems through technology. As the "how" becomes automated, the "why" and "for whom" become our core mandate. This requires a level of empathy, business acumen, and communication that AI cannot replicate.

This virtue manifests as:

  • Deep Domain Empathy: Moving beyond user stories to gain a profound understanding of the user's world, their frustrations, and their unstated needs.
  • Radical Collaboration: Acting as the connective tissue between product, design, security, and business stakeholders.
  • Articulate Translation: The ability to explain complex technical trade-offs and the implications of AI-driven decisions to non-technical leaders, enabling better collective decision-making.

These engineers ensure the powerful engine of AI is pointed in the right direction, creating solutions that are not just technically sound but also valuable and meaningful.

IV. Ethos (Ἦθος): Ethical Stewardship

With the immense power of AI comes an even greater responsibility. The virtue of ethos is the engineer's character and commitment to ethical stewardship. An AI has no conscience. It cannot weigh the societal impact of its creations. That responsibility falls squarely on us.

Ethical stewardship requires engineers to be the guardians at the gate, asking:

  • Could this system perpetuate or amplify existing biases?
  • What are the privacy implications of the data this model requires?
  • How can this system be misused, and what safeguards can we build to prevent it?
  • Are we building systems that empower and augment humanity, or ones that de-skill and displace without a just transition?

This is no longer a niche concern for an ethics committee; it is a core, non-negotiable engineering responsibility at every stage of the lifecycle.

The Recipes: Hiring and Nurturing These Virtues

Recognizing these virtues is the first step. Cultivating them is the work that will define successful engineering organizations for the next decade. Here is how we begin to operationalize this philosophy.

Recalibrating Hiring

Our interview processes, often optimized for algorithmic prowess, must be re-engineered:

  • From LeetCode to Dilemmas: Supplement algorithmic challenges with open-ended architectural and ethical dilemma questions. Ask candidates to critique an AI-generated solution.
  • System Design with Ambiguity: Present system design problems where the requirements are intentionally vague, testing their ability to ask clarifying questions (Arete) and make reasoned assumptions (Phronesis).
  • Code Deconstruction: Give them a moderately complex, AI-generated piece of code and ask them to analyze it for bugs, security flaws, and long-term maintainability issues (Techne).

Nurturing a Culture of Excellence

Productivity cannot be the only metric of success. We must create environments where these virtues are celebrated and rewarded:

  • Celebrate "Intelligent Deletion": Reward the engineer who wisely argues *against* building something, saving the company from pursuing a technically feasible but strategically flawed path.
  • Mandatory "Why" Reviews: In code and design reviews, the first question must always be "Why is this the right problem to solve, and why is this the right way to solve it?" not just "Does the code work?".
  • Cross-Functional Guilds: Establish guilds focused not on technologies (e.g., "React Guild"), but on virtues (e.g., "System Integrity Guild," "Ethical Design Guild").

Conclusion: The Enduring Edge

The rise of Generative AI is not a threat to the serious software engineer; it is a clarion call to elevate our craft. It automates the syntax so we can master the semantics. It handles the rote so we can focus on the profound. It provides answers so we can learn to ask better questions.

The enduring human edge in an age of intelligent machines will not be found in our ability to write code faster. It will be found in our wisdom, our craftsmanship, our purpose, and our character. By consciously cultivating these four virtues, we can transform our teams from simple builders into the master architects of a future where technology serves humanity with unparalleled excellence and integrity.


Caveat: The Gen AI Advantage

I have most certainly used LLMs to augment this post. More than one. Just like "you" are the driver in Tesla Autopilot (yet), in post like this one, or in software engineering, "you" remain the driver and responsible for content.

Further Reading & References

  • Aristotle. (c. 340 BCE). Nicomachean Ethics.

    The foundational text for the virtues discussed, particularly Book VI's analysis of intellectual virtues like phronesis and techne.

  • Vallor, Shannon. (2016). Technology and the Virtues: A Philosophical Guide to a Future Worth Wanting.

    An essential modern work that directly applies Aristotelian and other virtue ethics to 21st-century technology, including AI, robotics, and social media.

  • Flyvbjerg, Bent. (2001). Making Social Science Matter: Why Social Inquiry Fails and How It Can Succeed Again.

    While focused on social science, this book contains the most influential modern analysis of phronesis as a form of practical, value-based rationality distinct from purely technical knowledge.

  • O'Neil, Cathy. (2016). Weapons of Math Destruction: How Big Data Increases Inequality and Threatens Democracy.

    A critical examination of how algorithms can encode bias and cause harm, underscoring the profound need for the virtue of ethos in modern engineering.

  • Fowler, Martin. (2018). Refactoring: Improving the Design of Existing Code, 2nd Edition.

    A canonical text on software craftsmanship. The practice of refactoring is a perfect example of techne—a disciplined, principle-driven approach to improving system health.

  • Norman, Don. (2013). The Design of Everyday Things: Revised and Expanded Edition.

    The classic book on human-centered design. Its lessons on understanding user needs and creating intuitive systems are fundamental to developing arete, or excellence in purpose.

Monday, April 21, 2025

Rise of the AI‑Assisted Polyglot Developer



“The real power of AI‑powered coding isn’t in replacing developers, but in amplifying our ability to solve problems across languages and domains.”


In recent years, I’ve leaned on large language models (LLMs) to automate small scripting tasks—everything from refactored Bash scripts to Python data pipelines. These quick fun achievements have kept me wondering: What if I could harness these models to accelerate real full‑stack development? Today I lead engineering teams through complex digital transformations. Yet my itch to build never went away. So, when an old MNIT Jaipur classmate asked for help on his startup’s SQL reporting pains, I saw an opportunity to scratch that itch—and explore how large language models (LLMs) could turbo‑charge full‑stack development.. What started as a simple SQL‑reporting utility blossomed into a deep dive into vibe coding, agentic workflows, and a renewed appreciation for human‑AI collaboration.

The Business Challenge

His operations lead needed ad‑hoc reports: log into a relational database, hand‑craft SQL, massage the output into CSVs. Simple—but manual, slow, and error‑prone. Could we embed a “smart” query assistant directly into his Vercel‑hosted dashboard, letting anyone ask natural‑language questions like:

“Show me total sales by region for Q1.”

…and instantly get a table, chart, or CSV?

Diagram of LLM‑powered pipeline as below



Picking the Stack—Pain Points Included

With years of back‑end muscle memory, I initially sketched a Python backend for the LLM logic, with a Next.js front end. But Vercel’s platform pushes you toward a single runtime. After wrestling with mixed‑language builds, I pivoted: all‑in‑JavaScript/TypeScript on Node.js.

The learning curve was steep. I had to:

  1. Discover Vercel’s “v0 agentic mode” and its limitations (free‑tier quotas, usage warnings).

  2. Get up to speed on shadcn/ui and Tailwind CSS for rapid UI prototyping.

  3. Relearn Next.js conventions for server‑side API routes vs. edge functions.

By the end of Week 1, I had a skeletal “Table‑Stakes” project up on GitHub—and a burning question: How fast could I really go if I let an AI agent handle the plumbing?


Enter Vibe Coding

“Vibe coding” loosely describes a workflow where you direct an AI agent—via tools like Claude Sonnet 3.7 or ChatGPT—with short, intent‑based prompts, then iterate on its outputs in situ. It promised to:

  1. Bootstrap boilerplate instantly

  2. Generate utility functions on demand

  3. Suggest best‑practice snippets (e.g., secure DB access)

…all without context‑switching between Stack Overflow, boilerplate repos, and your IDE.

But the ecosystem is messy: cline, Claude Code, Windsurf, Cursor—and each comes with its own CLI quirks, and not all work by default on Windows. No one had written a clear tutorial. So, I leaned on ChatGPT to draft my “starter kit” for vibe coding. I settled on Claude Sonnet 3.7 for agentic coding and VS Code for its rich extension ecosystem



Trials, Errors, and Quotas

A few lessons surfaced immediately:

  1. Agent vs. API billing
    Paid Claude Pro credits don’t apply to Sonnet’s agent API—unexpected costs ticked up quickly.

  2. Syntax habits
    On Windows, early agent runs insisted on && between commands. After a few painful debug loops, I explicitly prompted:

    “Use semicolons to chain shell commands on Windows.”

    This worked mostly, but it still kept chaining them wrongly and fixing, wasting enough cycles as below:


     

  3. Tool limitations
    LLMs excel at fuzzy thinking (drafting logic, naming conventions) but can be weak in identifying the "right" thing to do. When faced with a challenge of compile time issue with a library that required older Node version, it kept trying to use --legacy-peer-deps instead of upgrading the library version, even though when explicitly prompted it was able to see there is a newer version.

  4. Security and Testing as second grade citizens

The agentic mode created decent code but it completely missed adhering to security best practices or adding test cases and all of those had to be added separately. While it was able to add security controls, it had a really tough time adding unit tests. The following diagrams show lack of test coverage when code was generated and relatively severe security findings when I prompted and asked to fix:





 


Productivity Unleashed—With Caveats

With the environment squared away, I completed a working MVP in two nights—from DB‑query endpoint to a polished UI. Agents generated:

  1. Next.js pages with form inputs

  2. API wrappers for PostgreSQL

  3. Client‑side chart components

All punctuated by manual fixes/ prompts for: testing, security, and cross‑platform quirks.

My take: AI agents can nudge you toward a “10× developer” pace—maybe even 100× in raw code generation. But they still forget to:

  1. Sanitize user inputs against security vulnerabilities

  2. Write comprehensive unit and integration tests

  3. Handle edge‑case errors or rate limits gracefully

The following screenshot shows its attempts to fixing the issues when asked to. 




Testing—Is It Cheating?

Generating test stubs from an agent feels like a shortcut:

“Write unit and integration tests for entire codebase using mocks as appropriate.”

Sure, it works. But can you trust tests generated against code that was AI‑assembled? My bias says: write only integration tests that validate end‑to‑end behavior, and manually review critical units. That way, you’re testing the system, not just the agent’s understanding of code it generated.


The Human in the Loop

Throughout, my role was less “coder” and more “orchestrator”:

  1. Prompt architect

  2. Context curator

  3. Quality gatekeeper

I found that my domain expertise—knowing what the UX should feel like, understanding data‑schema trade‑offs, and recognizing security blind spots—was indispensable. The agent unlocked speed, but I guided purpose.


Where We Go from Here

AI‑assisted development is no longer science fiction. Its very much real, and very much in its infancy. Yet:

  1. Non‑technical users still face too many moving parts to trust these tools in production.

  2. Standardization (e.g., LSP‑style protocols for agents) is needed to bridge the “haves” and “have‑nots.”

  3. Community knowledge (deep tutorials, case studies) lags behind hype‑cycle content.

  4. Technical Domain knowledge will keep playing crucial role, e.g. difference in npm's dependency management vs maven's, or lack of Java like libraries like spring-data in nodejs will cause confusion until the ecosystems align

  5. Fast evolving landscape: I started with a known debt of not using MCP. But in the two-three weeks since I started coding and now, significant changes have happened. Firebase Studio has been launched that makes it much easier, GPT-4.1 has been launched and is arguably better than Claude 3.7. Finally, Claude has published best practices for agentic coding.

Still, I’m pretty excited. If a backend‑focused engineer like me with increasingly higher management experience can become a lightweight frontend dev in a weekend, it shouldn't be very long until well‑tuned agent by our side could help us achieve very large productivity gains


Getting Started Yourself

  1. Choose your agent: Claude Sonnet 3.7, ChatGPT Plugins, or GitHub Copilot.

  2. Set up a single‑language stack on your hosting provider (e.g., Node.js on Vercel / v0, or Firebase).

  3. Iterate with prompts—refine your instructions as you learn the agent’s quirks.

  4. Guardrails first: add linters, input validators, and integration tests early.

  5. Share your learnings: we need more deep‑dive tutorials, not just YouTube shorts or tweets.


Agents won’t replace us—but they will empower us to tackle more ambitious problems, faster. Embrace the rise of the AI‑assisted polyglot developer, and let’s build the future, one prompt at a time.

Check out the full project on GitHub:
https://github.com/AbhiramDwivedi/table-stakes