Skip to content

English - The New Programming Language

The first time I used a coding assistant, I thought it was impressive but not game-changing. A few months later, after diving into a new codebase, I realized I was wrong. What would have taken me weeks to understand and refactor manually, I was able to accomplish in a day. It wasn't just faster—it was a different way of working.

We're living through change in how software gets built. Coding assistants are adding productivity gains, and engineers who embrace them are achieving things that seemed impossible just a year ago.

The Traditional Development Bottleneck

Software development has always had roadblocks. When you join a project, you typically spend weeks understanding the codebase. Reading documentation, figuring out design decisions, understanding where everything lives.

However, while these activities are important, they take time away from delivering direct business value. For many engineers, switching to a new technology stack or framework can feel overwhelming—the learning curve is steep, the documentation dense, and the risk of mistakes ever-present.

Programming with Natural Language

LLM-powered coding assistants are solving these problems by making English the primary programming interface. Instead of remembering syntax or spending hours reading documentation, you can describe what you want in natural language and get work started instantly.

The real breakthrough isn't that LLMs can write code—it's that they understand what you're trying to achieve. You describe the outcome, and it handles the building steps. This flips the entire development process on it's head.

The AI-Assisted Development Workflow

Let me show you how this works in practice. Here's the workflow that I use when working with existing codebases.

(Note: If you're building something from scratch, you'll still need proper design documents and architectural planning before diving into implementation)

Phase 1: Discovery and Understanding

Never start by asking for code. Start with understanding. AI can scan thousands of files in minutes to give you a complete picture. Key questions to ask:

Analyze this codebase and provide a high-level overview of:
1. Technologies, frameworks, and architecture
2. Project structure and module organization
3. Build, test, and deployment processes

"Trace the checkout process from 'Checkout' click to order confirmation, including components, API calls, and state management."

Debug 500 errors in the user profile endpoint by examining:
- Request flow and database schema
- Auth flow and error handling
- Recent changes in this area

Deep Dive Questions for Critical Understanding

Once you have the overview, you can narrow it down to more specific questions. Here are some examples:

Show me the data flow for user authentication, including:
- Frontend components
- API endpoints
- Database interactions
- Session management
- Security validations

Analyze the shopping cart functionality and identify:
- State management approach
- Persistence strategy
- Concurrency handling
- Error cases and edge cases
- Performance considerations

Explain the notification system architecture:
- How are real-time updates handled?
- What's the fallback mechanism?
- How are different notification channels managed?
- What's the retry strategy for failed notifications?

Phase 2: Planning and Design

Thorough planning prevents implementation issues. Here are key planning prompts:

API Design 

Design a RESTful API for user profiles with CRUD operations.
Include: endpoints, request/response schemas, status codes, and error handling.

Verification:
- List endpoints with methods and paths
- Define schemas with example payloads
- Document status codes and errors
- No implementation yet

Database Schema 

Design an e-commerce database with:
- Products (with variations)
- Users and orders
- Shopping carts
- Categories and tags

Verification:
- Table structures with relationships
- Key fields and constraints
- Indexing strategy

Component Architecture 

Plan a task management dashboard with:
- Navigation sidebar
- Task list view
- Add/edit modals
- Filtering/sorting

Verification:
- Component hierarchy
- Props/state structure
- State management approach

Universal Verification Template 

Before implementing, provide:
1. Files to create/modify
2. Required dependencies
3. Potential risks
4. Testing approach
5. Rollback plan

No code yet - planning only.

Phase 3: Implementation with Validation

TDD Implementation 

Implement password reset with TDD:
1. Test reset request flow
2. Test token generation/storage
3. Test password update
4. Test email notification
Write minimal code to pass each test.

API Development 

Build product search endpoint with:
- Pagination
- Filters (category, price, availability)
- Full-text search
- Sorting
Start with test cases.

Frontend Components 

Create responsive data table with:
- Sorting/filtering
- Pagination
- Row selection
- Loading states
Use React + TypeScript + tests.

Code Refactoring 

Refactor payment processing:
1. Analyze current code
2. Identify issues
3. Add tests
4. Refactor incrementally
5. Verify tests pass

Performance Tuning 

Optimize slow endpoint:
1. Profile performance
2. Find bottleneck
3. Implement fixes
4. Measure improvements

The "Show, Don't Do" Pattern

Always request a plan before implementation:

Plan the refactoring of payment processing:
1. Current issues
2. Proposed solution
3. Affected files
4. Potential risks
5. Test coverage needed

Review and approve the plan before proceeding with changes.

Effective Prompting

Treat English as a programming language with its own best practices.

Context is Key

Provide clear context like briefing a new team member:

Weak: 

"fix this bug"

Strong: 

"Debug 404 at /api/users:
1. Check routing and controllers
2. Review connection layer
3. Propose solution with steps
4. Present changes for review"

TDD Development with LLMs

1. Red Phase - Writing Failing Tests

Write a failing test for a user registration endpoint that verifies:
- Valid email format is required
- Password must be at least 8 characters
- Username must be unique

2. Green Phase - Minimal Implementation

Implement the minimum code needed to make these registration tests pass, focusing only on the specified requirements.

3. Refactor Phase - Code Improvement

Refactor this implementation to follow SOLID principles while keeping all tests passing. Focus on:
- Single responsibility
- Dependency injection
- Clean, maintainable structure

4. Iterative Enhancement - Adding Features

Add test cases for multiple user signups at once and implement the necessary locking mechanism to handle race conditions.

The Compounding Returns

The speed advantage creates growing benefits. When you can prototype faster, you iterate more. When you iterate more, you learn faster. When you learn faster, you make better architectural decisions. When you make better decisions, your next project starts from a higher baseline.

I've watched this play out across multiple projects. Teams using coding agents effectively aren't just moving faster—they're building better software because they have more time for thoughtful design and thorough testing.

Beyond Just Code

LLM assistance now extends to:

  • Project Management: Jira ticket creation and tracking (via MCP)
  • Documentation: Confluence page management (via MCP)
  • Infrastructure: AWS cost optimization and resource management
  • System Administration: Safe server configuration changes
  • Quality Assurance: Automated testing and code standards

MCP integrations expand capabilities to various development tools.

Getting Started

Tools I recommend:

  • IDE: Windsurf with Claude Code integration
  • For simpler tasks: Cascade or SWE-agent

Getting started:

  1. Begin with a small, well-defined task
  2. Practice the explore-plan-implement cycle
  3. Gradually expand to more complex tasks

Prompting best practices:

  • Be specific and provide context
  • Request explanations for complex solutions
  • Always ask for a plan before implementation
  • Review all generated code carefully
  • Test everything thoroughly

Remember: LLMs are powerful tools, but they're not infallible. They require critical thinking and code review.

The Next Chapter in Software Development

We're witnessing a fundamental shift in software engineering—from writing code to articulating intent in natural language. As English becomes the primary interface between engineers and their tools, the very nature of programming is being redefined.

The most effective engineers won't just write better code; they'll excel at clearly defining problems, structuring solutions, and guiding LLM tools to implement them. What sets them apart isn't just technical skill, but the capacity to think critically, communicate precisely, and make sound architectural decisions.

This transformation isn't far off—it's already here. The engineers who thrive will be those who embrace this evolution, master the art of programming in natural language while maintaining the rigor and discipline that great software demands.

Note: These approaches work well for me, but your usecase may vary. Experiment to find what works best for your workflow.