Jan Peter Alexander

There is nothing certain than the uncertainty itself. Capture, learn and mitigate. Welcome!

TL;DR:

  • Plan → Implement → Validate: Three-phase methodology consuming 60-70% effort in planning
  • Context Engineering: Master RAG, codebase analysis, and requirements gathering for AI success
  • Custom Workflows: Build personalized slash commands and sub-agents that evolve with your projects
  • Task Management: Granular breakdown prevents AI context loss and ensures consistent implementation
  • Quality First: Integrated validation throughout process with human oversight and specialized tools
  • Philosophy Over Tools: Understanding principles to create systems tailored to your development style

Beyond the Prompt: Building a Scalable System for AI-Assisted Development

The Limitations of Prompt-Centric Development

In the rapidly evolving landscape of AI-assisted coding, many developers find themselves stuck in a cycle of repetitive prompting—what might be called “prompt fatigue.” You ask the AI to generate code, it produces something close but not quite right, you refine the prompt, and the cycle continues. This approach mirrors the pitfalls of “vibe coding” that experienced developers have long cautioned against: a lack of structure leading to technical debt, inconsistent quality, and ultimately, more work than necessary.

The truth is, effective AI-assisted development isn’t about finding the perfect prompt. It’s about building systems and workflows that can evolve with your projects and coding style. While frameworks like PRP, BMAD, and GitHub’s Spec Kit offer valuable strategies, the real power comes from understanding the underlying principles that make these frameworks effective. This understanding enables you to create custom workflows tailored to your specific needs.

The Core Mental Model: Plan, Implement, Validate

At the heart of any effective AI development workflow lies a simple but powerful three-phase mental model:

  1. Planning - Curating context and requirements
  2. Implementation - Executing with precision
  3. Validation - Ensuring quality and correctness

This framework provides the structure needed to scale AI assistance from small scripts to substantial projects. Let’s explore each phase in depth.

Phase 1: Planning - The Foundation of Success

Planning is arguably the most critical phase, consuming approximately 60-70% of the overall effort in AI-assisted development. Poor context curation is the primary reason AI coding assistants “fall on their face” with complex tasks.

Stage 1: Vibe Planning - Structured Exploration

Contrary to “vibe coding,” which implies careless implementation, “vibe planning” is about purposefully unstructured exploration at the beginning of a project. This is where you and your AI assistant research together as companions.

For new projects:

  • Research architectural patterns and tech stacks
  • Analyze similar projects or examples
  • Explore different approaches to the problem domain
  • Create an examples/ folder with relevant codebases for the AI to reference

For existing projects:

  • Analyze the current codebase structure
  • Identify integration points for new features
  • Research how similar features were implemented previously
  • Understand the project’s patterns and conventions

The key is maintaining a free-form conversation style during this phase, allowing for creative exploration without the constraints of immediate implementation.

Stage 2: Creating the Initial Requirements Document

Once exploration is complete, transition to creating what I call the “Initial MD”—a markdown-based Product Requirements Document (PRD). This document should be understandable by both humans and AI, containing:

  • High-level feature description in plain language
  • Key user stories or use cases
  • Technical constraints and considerations
  • References to examples discovered during vibe planning
  • Integration points with existing code (for existing projects)

This document serves as a bridge between exploratory thinking and structured planning.

Stage 3: Context Engineering - The Detailed Plan

This is where strategic context engineering transforms your requirements into an actionable plan. Start a fresh conversation with your AI assistant and use a specialized slash command (like /create_plan) to generate a comprehensive plan.md.

The planning process should include:

  1. Requirements Analysis - Deep understanding of the Initial MD
  2. RAG (Retrieval-Augmented Generation) Research - Using tools like web search or Archon to gather external documentation
  3. Codebase Analysis - Often using sub-agents to deeply understand existing code without polluting the main conversation context
  4. Task Decomposition - Breaking the project into granular, manageable tasks
  5. Success Criteria Definition - Clear metrics for completion and quality

Example plan.md structure:

# Project Plan: OpenAI API Compatibility Layer

## Overview
[Detailed description from requirements]

## Task List
1. [ ] Create API endpoint stubs
2. [ ] Implement authentication middleware
3. [ ] Add request/response formatting
...

## Desired Codebase Structure
- `src/api/` - New endpoint implementations
- `src/middleware/` - Authentication and validation
...

## Reference Documentation
- [OpenAI API docs]
- [Existing authentication patterns in codebase]
...

## Success Criteria
- All endpoints respond with correct format
- Authentication integrates with existing system
- 100% test coverage on new code

The output is essentially what frameworks like PRP generate, but by building it yourself, you understand and control every aspect.

Phase 2: Implementation - Precision Execution

With a solid plan, implementation becomes a matter of disciplined execution rather than hopeful prompting.

Task Management: The Key to Reliable Implementation

The most common failure mode in AI implementation is attempting too much in a single request. Proper task management prevents this through:

Granular Task Breakdown Each task should be small enough that the AI can complete it without losing context or hallucinating. A good rule of thumb: if a task would take a human developer more than 30-60 minutes, it’s probably too large.

Workflow Automation with Slash Commands Create specialized slash commands for your implementation workflow. For example, an /execute_plan command might:

  1. Parse the plan.md and create tasks in a management tool like Archon
  2. Set up the project structure if needed
  3. Cycle through tasks: mark as “in progress,” implement, mark for review
  4. Invoke validation sub-agents at appropriate checkpoints

Critical Implementation Principle: No Sub-Agents for Code Generation

While sub-agents are excellent for research and validation, they should not be used for actual code implementation. Here’s why:

  • Context Isolation: Sub-agents operate in separate context windows, meaning they don’t share memory of changes made by other agents
  • Inconsistent Patterns: Different agents might implement similar functionality in conflicting ways
  • Integration Challenges: Without shared context, integrating components becomes difficult

All implementation should happen in your primary AI’s context window to maintain consistency and coherence.

Example Implementation Cycle

A well-structured implementation might follow this pattern:

Load plan.md → Create tasks in Archon → 
For each task:
  - Mark task as "in progress"
  - Analyze relevant code sections
  - Implement changes
  - Run basic validation
  - Mark task as "review"
  - Move to next task
→ Final comprehensive validation

This disciplined approach ensures that each change is focused and validated before moving forward.

Phase 3: Validation - Ensuring Quality

Validation is not an afterthought—it’s integrated throughout the process, with increasing intensity as implementation progresses.

AI Self-Validation

Build validation checkpoints into your workflow:

During Implementation:

  • After each task, have the AI review its own work against the success criteria
  • Run automated tests or syntax checks
  • Verify that changes integrate properly with existing code

Post-Implementation Validation: Use specialized validation sub-agents with focused system prompts to:

  • Run comprehensive test suites
  • Check for common security vulnerabilities
  • Verify adherence to coding standards
  • Generate test coverage reports

Human-in-the-Loop Validation

Despite AI capabilities, human oversight remains crucial:

Code Review Practices:

  • Review all AI-generated code with the same rigor as human-written code
  • Look for understanding, not just functionality—does the code make sense?
  • Check for consistency with project patterns and conventions

Manual Testing:

  • Actually run and use the implemented features
  • Test edge cases and error conditions
  • Verify integration with existing systems

Leveraging Specialized Tools

Tools like Code Rabbit can augment your validation process by:

  • Providing deep codebase analysis
  • Generating architectural diagrams showing how changes affect the system
  • Suggesting specific improvements and identifying potential issues
  • Integrating with your CI/CD pipeline for automated reviews

Building Your Custom Workflow System

The true power comes from combining these elements into a reusable system tailored to your needs.

Component 1: Global Rules

Establish foundation rules that apply to all projects in your claude.md (or equivalent):

  • Coding standards and style guidelines
  • Security and best practice requirements
  • Documentation expectations
  • Testing requirements

These rules become the bedrock of consistency across all your AI-assisted development.

Component 2: Specialized Slash Commands

Build a library of reusable slash commands for different scenarios:

Planning Commands:

  • /primer - Quickly onboard the AI to an existing project
  • /vibe_plan - Start exploratory planning for new features
  • /create_plan - Generate detailed implementation plans

Implementation Commands:

  • /execute_plan - Run the full implementation workflow
  • /add_feature - Add smaller features to existing codebases
  • /refactor - Specialized refactoring workflows

Validation Commands:

  • /validate - Run comprehensive validation suites
  • /review - Conduct code reviews
  • /test - Generate and run tests

Component 3: Sub-Agent Specialization

Create specialized sub-agents for specific purposes:

Research Agents:

  • Deep codebase analysis without context pollution
  • External documentation research
  • Pattern identification and recommendation

Validation Agents:

  • Security scanning specialists
  • Performance optimization reviewers
  • Testing and quality assurance focused agents

Component 4: Integration with Development Tools

Connect your AI workflow to existing tools:

  • Version Control: Automated commit messages and branch management
  • Project Management: Task creation and status updates in tools like Archon
  • CI/CD: Automated testing and deployment triggers
  • Documentation: Automatic documentation generation and updates

Real-World Example: Building an Obsidian AI Integration

Let’s examine how this workflow applied to a real project: creating an OpenAI-compatible API for a custom AI agent integrated with Obsidian.

Planning Phase:

  • Vibe planning explored existing Obsidian plugin patterns
  • Initial MD defined the API endpoints and integration points
  • Detailed plan.md broke down implementation into 15 granular tasks

Implementation Phase:

  • Used /execute_plan command with task management in Archon
  • Each endpoint implementation was a separate, focused task
  • Maintained all implementation in primary Claude context

Validation Phase:

  • Validation sub-agent ran comprehensive tests
  • Manual testing involved actual API calls from Obsidian
  • Code review ensured integration with existing agent architecture

The result was a flawless implementation that worked correctly on the first real test—a summary request processed through the newly built API endpoints.

Adapting Existing Frameworks to Your System

Rather than replacing frameworks like PRP or BMAD, you can adapt them into your system:

  • Use PRP’s structured approach to enhance your planning phase
  • Incorporate BMAD’s project brief methodology into your requirement gathering
  • Integrate GitHub Spec Kit commands as specialized slash commands

The key insight is that these frameworks are implementations of the underlying principles we’ve discussed. Understanding the principles allows you to use the frameworks more effectively or build your own when they don’t quite fit your needs.

Conclusion: From Prompting to Engineering

The evolution from prompt-centric development to workflow engineering represents a fundamental shift in how we approach AI-assisted coding. By building systems rather than just typing prompts, you gain:

  1. Consistency across projects and team members
  2. Scalability from small scripts to large applications
  3. Maintainability through structured processes and documentation
  4. Continuous Improvement as you refine your workflows over time
  5. Deep Understanding of both your codebase and AI capabilities

The most powerful outcome isn’t just better code—it’s the development of a personalized engineering system that grows with you. Whether you’re working on personal projects, contributing to open source, or building enterprise applications, this systematic approach transforms AI from a novelty into a professional-grade engineering tool.

Remember: the goal isn’t to eliminate the human developer, but to create a partnership where human intelligence directs artificial intelligence toward truly excellent software engineering outcomes.

References

This analysis is based on the comprehensive guide presented in Cole Medin’s YouTube video “Kekuatan Sejati Pengodean AI - Bangun Alur Kerja Anda SENDIRI (Panduan Lengkap)”, exploring the philosophy and practical implementation of custom AI coding workflows.

You May Also Enjoy