In preparing for battle I have always found that plans are useless, but planning is indispensable

Thanks Dwight for this quote. This quote highlights the idea that while a specific, detailed plan might become obsolete once a situation begins, the act of planning itself—the critical thinking, foresight, and preparation it entails—is essential for adapting to unexpected circumstances and achieving success.

Plans vs. Planning

Eisenhower distinguishes between the static plan (a document or outline) and the dynamic process of planning (the mental exercise of thinking, strategizing, and preparing).

Real-world adaptability

In military and other high-stakes environments, initial plans are rarely followed exactly. The enemy’s actions, unforeseen circumstances, or other unpredictable factors mean a rigid plan becomes useless. 

Indispensable process

The value lies in the act of planning. It forces you to consider possibilities, develop contingencies, and build the mental and physical capabilities to adapt and make quick decisions when things change.

How it applies to Agentic Coding

Eisenhower’s insight that “plans are useless, but planning is indispensable” resonates deeply with the concept of Agentic Code Development, where autonomous or semi-autonomous agents write, test, and adapt code.

In this context, the “plans” can be seen as the initial, detailed code specifications or development roadmaps that an agent or team might create before starting the coding process. These plans often become outdated quickly due to changing requirements, unforeseen bugs, or new insights during development.

However, the “planning”—the ongoing process of critical thinking, problem-solving, and iterative refinement—is what truly empowers agentic code development. This continuous planning enables the agent(s) to:

• Anticipate potential challenges and edge cases.Adapt dynamically to new information or shifting project goals.
• Make informed decisions about code structure, testing, and deployment.
• Maintain flexibility to pivot or refactor as needed without being rigidly bound to an initial plan.

Adapt dynamically to new information or shifting project goals

Agentic code development thrives on flexibility. When project requirements change—say, a client decides to add multi-language support or switch from a SQL to a NoSQL database—the agent must quickly incorporate these changes without starting from scratch. This requires continuous reassessment and adjustment of the codebase and development priorities.

Real example: A code-generating agent initially builds a web app with a single language interface. Midway, the client requests localization for multiple languages. The agent dynamically integrates internationalization libraries and restructures UI components to support language switching, all while preserving existing functionality.

In my case: More that I care to admit, I start coding, or start building an app with a tool, way before I should. It is hard to resist the urge to make something.

Make informed decisions about code structure, testing, and deployment

Planning involves evaluating trade-offs and choosing the best approaches. An agent might decide between a microservices architecture versus a monolithic design based on scalability needs. It also plans testing strategies—unit tests, integration tests, or end-to-end tests—to ensure code quality. Deployment decisions, such as using containerization or serverless functions, are made based on performance and cost considerations.

Real example: An agent developing an e-commerce platform opts for a modular code structure to isolate payment, inventory, and user management components. It implements automated unit tests for each module and sets up continuous integration pipelines to deploy updates safely and quickly.

In my case: Hey one more like of code or functionality can hurt. It is going to take me a couple of hours. Wrong more times that right.

Maintain flexibility to pivot or refactor as needed without being rigidly bound to an initial plan

Initial plans often become obsolete as new insights emerge. Agentic code development embraces refactoring and pivoting. For instance, if performance bottlenecks are detected, the agent might refactor critical code paths or switch algorithms. If user feedback reveals usability issues, the agent can redesign interfaces or workflows.

Real example: After launching a social media app, an agent notices slow load times due to inefficient database queries. It refactors the data access layer to use optimized indexing and caching strategies, improving responsiveness without discarding the entire codebase.

In my case: How hard could it be to …… How many times that simple phrase has derailed a project?

Benefits of Ignoring Continuous Planning

• Faster Initial Development. Skipping detailed planning can speed up the initial coding phase, allowing agents to produce a working prototype or MVP quickly without getting bogged down in analysis or design.
• Reduced Upfront Complexity. Without extensive planning, the development process might feel simpler or more straightforward at first, avoiding paralysis by analysis or over-engineering.
• Encourages Experimentation. Ignoring rigid plans can foster a more experimental, trial-and-error approach where agents try out ideas rapidly and learn from immediate feedback.

Problems of Ignoring Continuous Planning

• Increased Risk of Bugs and Failures. Without anticipating challenges and edge cases, the code is more likely to break under unexpected conditions, leading to unstable or insecure software.
• Difficulty Adapting to Change. When project goals or requirements shift, lack of ongoing planning makes it harder for agents to pivot efficiently, often resulting in costly rewrites or technical debt.
• Poor Technical Decisions. Without informed planning, agents may choose suboptimal architectures, testing strategies, or deployment methods, which can hurt scalability, maintainability, and performance.
• Rigid Codebase and Reduced Agility. Ignoring planning leads to brittle code that resists refactoring or extension, making it difficult to improve or evolve the software as new needs arise.
• Wasted Resources and Time. The absence of foresight often causes repeated fixes, patches, and rework, ultimately slowing down progress and increasing development costs.

In essence, while ignoring continuous planning might offer short-term speed or simplicity, it usually results in long-term inefficiencies, lower software quality, and reduced ability to respond to evolving challenges in agentic code development.

As a final thought, I want to talk about A PRD. Is this a new innovated and game changing document, most certainly not. Humans have been using these types of documents for years, but is worth saying hi again:

A Project Requirement Document (PRD) is a comprehensive document that outlines the goals, features, and functionalities of a software product or system. It serves as a blueprint for the AI Agent, ensuring a clear understanding of what needs to be built. The PRD also acts as a reference point throughout the project lifecycle, helping to manage scope, track progress, and validate the final product.

Told you, we all have used it.