1. Introduction

In previous articles, we have discussed the application of the V-model and the division of roles in the Eric-George Method. This article reports on a case study where the Eric-George Method was actually applied in the v2.19 development of a web application.

v2.19 was developed to solve a practical problem of style breakdown in blog posts. We will share the overall picture of the development, measured data, and lessons learned from the practice.

2. v2.19 Development Overview

2-1. Background and Objectives of Development

On January 8, 2026, a problem was discovered where Markdown-formatted text was displayed as-is in blog posts on the web application. Headings and paragraphs were not correctly converted to HTML, making them difficult for users to read.

To resolve this issue, it was decided to implement a Markdown to HTML conversion function.

2-2. Development Requirements and Constraints

The following requirements and constraints were set for this development:

• Functional Requirements: Correctly convert Markdown text to HTML and display it legibly.
• Non-functional Requirements: Absolutely no impact on existing functions (top page, fortune-telling form).
• Technical Constraints: Avoid adding external libraries; implement using only standard functions.

3. Development Process and Measured Data

3-1. Eric-George Collaboration Process

3-1-1. Problem Analysis by Eric

Upon receiving reports of blog post style breakdown, Eric identified the root cause using the following steps:

1. Symptom Confirmation: Investigated the HTML source of the blog page and confirmed that Markdown text was displayed as-is.
2. Hypothesis Building: Inferred that a conversion process was missing due to the difference between the format stored in the database and the browser display.
3. Code Investigation: Checked webapp/functions/_middleware.ts and confirmed the absence of Markdown processing.
4. Root Cause Identification: Concluded that Markdown to HTML conversion needed to be performed in the middleware.

Through this analysis, Eric formulated an implementation policy: "make minimal changes to existing code and limit the impact only to blog posts."

3-1-2. Implementation Directive Created by Eric

Eric created an implementation directive for George, including the following contents:

## Implementation Directive: Adding Markdown to HTML Conversion

### Target File
webapp/functions/_middleware.ts

### Implementation Policy
1. Apply only to blog post paths (/blog/...)
2. Implement the following conversion rules:
   - # → &l;t;h2&g;t;, ## → &l;t;h3&g;t;, ### → &l;t;h4&g;t;
   - Enclose paragraphs with &l;t;p&g;t;
   - Convert newlines to &l;t;br&g;t;
3. Guarantee zero impact on existing features
4. Security: Apply HTML escaping

### Test Items
- Blog post display confirmation
- Top page operation confirmation
- Fortune-telling form operation confirmation

A characteristic of this directive is that it specifies concrete implementation policies and clear test criteria.

3-1-3. Implementation by George

Based on Eric's implementation directive, George performed the following implementation:

// webapp/functions/_middleware.ts (excerpt)

function convertMarkdownToHtml(markdown: string): string {
  let html = markdown;
  
  // Heading conversion (process from level 3 in order)
  html = html.replace(/^### (.+)$/gm, '&l;t;h4&g;t;$1&l;t;/h4&g;t;');
  html = html.replace(/^## (.+)$/gm, '&l;t;h3&g;t;$1&l;t;/h3&g;t;');
  html = html.replace(/^# (.+)$/gm, '&l;t;h2&g;t;$1&l;t;/h2&g;t;');
  
  // Paragraph processing
  html = html.split('\\n\\n').map(para => {
    if (!para.startsWith('&l;t;h')) {
      return `&l;t;p&g;t;${para.replace(/\\n/g, '&l;t;br&g;t;')}&l;t;/p&g;t;`;
    }
    return para;
  }).join('\\n');
  
  return html;
}

// Apply only to blog posts
if (url.pathname.startsWith('/blog/')) {
  const content = await response.text();
  const convertedContent = convertMarkdownToHtml(content);
  return new Response(convertedContent, response);
}

Characteristics of George's implementation:

• Simple Regular Expressions: Implemented only the minimum necessary conversions without using external libraries.
• Clear Conditional Branching: Limited the target with url.pathname.startsWith('/blog/') to prevent impact on existing features.
• Priority Processing of Headings: Processed from heading level 3 in order to avoid regular expression matching problems.

3-2. Measured Data and Causal Relationship with the Method

We analyze the measured data from v2.19 development in terms of its causal relationship with each element of the Eric-George Method:

4. Technical Challenges and Solutions

4-1. Regular Expression Processing Order

For Markdown heading conversion, the processing order of heading levels is crucial. If processed from level 1 (#), levels 2 (##) or 3 (###) might be incorrectly matched.

Solution: George avoided this problem by processing from heading level 3 in order. This was explicitly stated in Eric's implementation directive.

4-2. Preventing Impact on Existing Features

To prevent impact on areas other than blog posts (top page, fortune-telling form), a conditional branch url.pathname.startsWith('/blog/') was introduced.

Effect: This conditional branch achieved zero impact on existing features and significantly reduced the effort for regression testing.

5. Improvements and Future Outlook

5-1. Improvements

The improvements gained from this development are as follows:

• Standardization of Implementation Directives: Standardize the format of Eric's implementation directives into a template and apply it to future development.
• Clarification of Test Items: Define test items to verify "zero impact on existing features" at the early stages of development.
• Documentation: Save Eric-George conversation logs and utilize them as reference materials for the future.

5-2. Future Outlook

For the future development of the Eric-George Method, we are considering the following:

1. Application to Complex Feature Development: Expand application to more complex development, such as database design and authentication functions.
2. Evolution of AI Models: Further improve Eric's analysis accuracy by transitioning to AI models with more advanced reasoning capabilities.
3. Quantification of Quality Metrics: Continuously measure metrics such as bug occurrence rate, development time, and rework rate to quantitatively evaluate the method's effectiveness.

6. Summary

This article reported on a practical case study of v2.19 development using the Eric-George Method. Key points are as follows:

• 0% Bug Occurrence Rate: Eric's thorough root cause analysis accurately identified the essence of the problem.
• No Additional Revisions: George completed the correct implementation on the first try thanks to specific implementation directives.
• Development Time Approx. Half a Day: Maximized the efficiency of each process through clear role division.
• Only 1 File Changed: Reduced testing effort and risk by adhering to the principle of minimal change.

The measured data from v2.19 development demonstrates the effectiveness of the Eric-George Method. We will continue to improve this method to achieve higher quality software development.