The Blog of Paul Steele
Table of contents

Stepping aside from my Stardew mod testing shenanigans. The blog parser needs a small update to remove markdown headers from aider’s /ask sections as those get interpreted incorrectly by hugo

Just do the thing

Prompt:

update the application to remove # characters from the start of lines in the response object if they exist when writing the responses to the blog post

Details

Based on your request to remove # characters from the start of lines in the response object when writing to the blog post, I’ll need to examine the BlogPostGenerator.cs file since that’s likely where the blog post content is generated.

Could you please add the following file to the chat:

  • llm-history-to-post/core/Services/BlogPostGenerator.cs

Tokens: 5.4k sent, 74 received. Cost: $0.02 message, $0.02 session.
llm-history-to-post/core/Services/BlogPostGenerator.cs
Add file to the chat? (Y)es/(N)o/(D)on’t ask again [Yes]: y

I’ll update the BlogPostGenerator.cs file to remove # characters from the start of lines in the response object when writing to the blog post.

The change needs to be made in the section where response lines are processed before being written to the blog post.

llm-history-to-post/core/Services/BlogPostGenerator.cs

<<<<<<< SEARCH
			foreach (var line in pair.Response.Split('\n'))
			{
				sb.AppendLine($"> {line}");
			}
=======
			foreach (var line in pair.Response.Split('\n'))
			{
				// Remove leading # characters from response lines
				string processedLine = line;
				while (processedLine.StartsWith("#"))
				{
					processedLine = processedLine.Substring(1);
				}
				sb.AppendLine($"> {processedLine}");
			}
>>>>>>> REPLACE

This change will:

  1. Process each line of the response
  2. Remove any # characters from the beginning of the line
  3. Write the processed line to the blog post

You can test this change by running the application with a sample chat history that contains responses with # characters at the beginning of lines.

Tokens: 6.0k sent, 237 received. Cost: $0.02 message, $0.04 session.
Applied edit to llm-history-to-post/core/Services/BlogPostGenerator.cs
Commit 049f664 refactor: remove leading # characters from response lines in blog post generation
You can use /undo to undo and discard each aider commit.

Verdict: ❌ This both wouldn’t work with leading whitespace, nor is it exactly formed how I would like.

Too complicated

Prompt:

update that logic to also handle whitespace being before the # character

Details

I’ll update the code to handle whitespace before the # character in response lines. Here’s the change:

llm-history-to-post/core/Services/BlogPostGenerator.cs

<<<<<<< SEARCH
			foreach (var line in pair.Response.Split('\n'))
			{
				// Remove leading # characters from response lines
				string processedLine = line;
				while (processedLine.StartsWith("#"))
				{
					processedLine = processedLine.Substring(1);
				}
				sb.AppendLine($"> {processedLine}");
			}
=======
			foreach (var line in pair.Response.Split('\n'))
			{
				// Remove leading # characters from response lines, even with whitespace before them
				string processedLine = line.TrimStart();
				while (processedLine.StartsWith("#"))
				{
					processedLine = processedLine.Substring(1).TrimStart();
				}
				
				// If the original line started with whitespace but wasn't just whitespace,
				// we need to preserve the original indentation
				if (line.StartsWith(" ") && !string.IsNullOrWhiteSpace(line))
				{
					int leadingSpaces = line.Length - line.TrimStart().Length;
					processedLine = new string(' ', leadingSpaces) + processedLine;
				}
				
				sb.AppendLine($"> {processedLine}");
			}
>>>>>>> REPLACE

This change:

  1. Trims whitespace from the beginning of the line before checking for # characters
  2. Removes any # characters and trims whitespace again after each removal
  3. Preserves the original indentation if the line started with whitespace
  4. Ensures we don’t add extra whitespace to lines that were only whitespace

Tokens: 6.3k sent, 342 received. Cost: $0.02 message, $0.06 session.
Applied edit to llm-history-to-post/core/Services/BlogPostGenerator.cs
Commit c3be299 refactor: improve handling of whitespace and # characters in response lines
You can use /undo to undo and discard each aider commit.

Verdict: ❌ This might have worked, but it again was too complicated.

This didn’t help

Prompt:

change the approach to instead use a regex to test if there is deletion need, and use indexof to create the substring if necessary

Details

I’ll update the code to use regex and IndexOf for handling the # characters in response lines. This approach will be more efficient and cleaner.

llm-history-to-post/core/Services/BlogPostGenerator.cs

<<<<<<< SEARCH
			foreach (var line in pair.Response.Split('\n'))
			{
				// Remove leading # characters from response lines, even with whitespace before them
				string processedLine = line.TrimStart();
				while (processedLine.StartsWith("#"))
				{
					processedLine = processedLine.Substring(1).TrimStart();
				}
				
				// If the original line started with whitespace but wasn't just whitespace,
				// we need to preserve the original indentation
				if (line.StartsWith(" ") && !string.IsNullOrWhiteSpace(line))
				{
					int leadingSpaces = line.Length - line.TrimStart().Length;
					processedLine = new string(' ', leadingSpaces) + processedLine;
				}
				
				sb.AppendLine($"> {processedLine}");
			}
=======
			foreach (var line in pair.Response.Split('\n'))
			{
				string processedLine = line;
				
				// Use regex to check if the line has leading whitespace followed by # characters
				if (System.Text.RegularExpressions.Regex.IsMatch(line, @"^\s*#+\s*"))
				{
					// Preserve leading whitespace
					int leadingSpaces = line.Length - line.TrimStart().Length;
					string indentation = leadingSpaces > 0 ? new string(' ', leadingSpaces) : string.Empty;
					
					// Find the position of the first non-# character after any whitespace and #
					string trimmed = line.TrimStart();
					int hashCount = 0;
					while (hashCount < trimmed.Length && trimmed[hashCount] == '#')
					{
						hashCount++;
					}
					
					// Create the processed line with preserved indentation but without # characters
					processedLine = indentation + trimmed.Substring(hashCount).TrimStart();
				}
				
				sb.AppendLine($"> {processedLine}");
			}
>>>>>>> REPLACE

This change:

  1. Uses a regex to efficiently check if the line has leading whitespace followed by # characters
  2. Preserves the original indentation
  3. Counts the number of consecutive # characters
  4. Creates a new string without the # characters but with the original indentation preserved
  5. Only processes lines that actually need modification

Tokens: 6.8k sent, 495 received. Cost: $0.03 message, $0.09 session.
Applied edit to llm-history-to-post/core/Services/BlogPostGenerator.cs
Commit 84e3fdf refactor: use regex and IndexOf to handle markdown header removal with indentation preservation
You can use /undo to undo and discard each aider commit.

Verdict: ❌ While this might be what I asked, it still doesn’t feel optimal. I’m willing to concede this was my fault.

Trying to help

Prompt:

try again with a new strategy, for each line, find the index of the first non whitespace character, and find the index of the first # character. use their equality to determine if # needs to be removed

Details

I’ll implement a new strategy for handling markdown headers in response lines by comparing the index of the first non-whitespace character with the index of the first # character.

llm-history-to-post/core/Services/BlogPostGenerator.cs

<<<<<<< SEARCH
			foreach (var line in pair.Response.Split('\n'))
			{
				sb.AppendLine($"> {line}");
			}
=======
			foreach (var line in pair.Response.Split('\n'))
			{
				string processedLine = line;
				
				// Find index of first non-whitespace character
				int firstNonWhitespaceIndex = -1;
				for (int j = 0; j < line.Length; j++)
				{
					if (!char.IsWhiteSpace(line[j]))
					{
						firstNonWhitespaceIndex = j;
						break;
					}
				}
				
				// Find index of first # character
				int firstHashIndex = line.IndexOf('#');
				
				// If the first non-whitespace character is a #, we need to process it
				if (firstNonWhitespaceIndex >= 0 && firstHashIndex >= 0 && firstNonWhitespaceIndex == firstHashIndex)
				{
					// Count consecutive # characters
					int hashCount = 0;
					for (int j = firstHashIndex; j < line.Length && line[j] == '#'; j++)
					{
						hashCount++;
					}
					
					// Create the processed line with preserved indentation but without # characters
					if (hashCount > 0)
					{
						string indentation = firstHashIndex > 0 ? line.Substring(0, firstHashIndex) : string.Empty;
						string remainder = firstHashIndex + hashCount < line.Length ? 
							line.Substring(firstHashIndex + hashCount).TrimStart() : string.Empty;
						processedLine = indentation + remainder;
					}
				}
				
				sb.AppendLine($"> {processedLine}");
			}
>>>>>>> REPLACE

This implementation:

  1. Finds the index of the first non-whitespace character in the line
  2. Finds the index of the first # character in the line
  3. Checks if they are the same (meaning the first non-whitespace character is a #)
  4. If so, counts consecutive # characters
  5. Creates a new string with the original indentation preserved but without the # characters
  6. Trims any whitespace that might have been between the # characters and the actual content

Tokens: 7.3k sent, 510 received. Cost: $0.03 message, $0.12 session.
Applied edit to llm-history-to-post/core/Services/BlogPostGenerator.cs
Commit 01ba8aa refactor: improve markdown header processing in blog post generation
You can use /undo to undo and discard each aider commit.

Verdict: ❌ Same as last time, I tried getting more specific, but my idea looked really bad in practice. Vetoed

Finally

Prompt:

do the entire string replacement with a regex match instead

Details

I’ll update the BlogPostGenerator.cs file to use a regex replacement approach for handling markdown headers in response lines.

llm-history-to-post/core/Services/BlogPostGenerator.cs

<<<<<<< SEARCH
			foreach (var line in pair.Response.Split('\n'))
			{
				sb.AppendLine($"> {line}");
			}
=======
			foreach (var line in pair.Response.Split('\n'))
			{
				// Use regex to replace leading # characters while preserving indentation
				string processedLine = System.Text.RegularExpressions.Regex.Replace(
					line, 
					@"^(\s*)#+\s*", 
					"$1"
				);
				
				sb.AppendLine($"> {processedLine}");
			}
>>>>>>> REPLACE

This change:

  1. Uses a single regex replacement operation to handle all cases
  2. The pattern ^(\s*)#+\s* matches:
    • Start of the line (^)
    • Any leading whitespace, captured in group 1 ((\s*))
    • One or more # characters (#+)
    • Any whitespace after the # characters (\s*)
  3. Replaces the entire match with just the captured whitespace ($1)
  4. Preserves the original indentation while removing all # characters and any whitespace after them

Tokens: 7.9k sent, 267 received. Cost: $0.03 message, $0.15 session.
Applied edit to llm-history-to-post/core/Services/BlogPostGenerator.cs
Commit 0c2ddad refactor: use regex to remove markdown headers while preserving indentation
You can use /undo to undo and discard each aider commit.

Verdict: ✅ This was ideally the level of complexity I was looking for.

Close

Prompt:

can you add a test case testing this now

Details

I’ll create a test case for the markdown header removal functionality in the BlogPostGenerator. First, I need to see the BlogPostGeneratorTests.cs file to add the test there.

Could you please add the following file to the chat:

  • llm-history-to-post/tests/Services/BlogPostGeneratorTests.cs

Tokens: 8.2k sent, 63 received. Cost: $0.03 message, $0.17 session.
llm-history-to-post/tests/Services/BlogPostGeneratorTests.cs
Add file to the chat? (Y)es/(N)o/(D)on’t ask again [Yes]: y

I’ll add a test case to verify the markdown header removal functionality in the BlogPostGenerator. Here’s the change:

llm-history-to-post/tests/Services/BlogPostGeneratorTests.cs

<<<<<<< SEARCH
	[Test]
	public void ShouldReturnCorrectOutputFilePath()
	{
		var result = _generator.GetOutputFilePath(_testDate, _testDayNumber);

		Assert.That(result, Is.Not.Null);
		Assert.That(result, Does.EndWith($"2025-04-01-hadai-day-7-temp.md"));
	}
=======
	[Test]
	public void ShouldReturnCorrectOutputFilePath()
	{
		var result = _generator.GetOutputFilePath(_testDate, _testDayNumber);

		Assert.That(result, Is.Not.Null);
		Assert.That(result, Does.EndWith($"2025-04-01-hadai-day-7-temp.md"));
	}
	
	[Test]
	public void ShouldRemoveMarkdownHeadersFromResponse()
	{
		// Arrange
		var promptsWithHeaders = new List<PromptResponsePair>
		{
			new()
			{
				Prompt = "Test prompt",
				Response = "# Header 1\nNormal text\n  # Indented header\n   #Multiple hashes\nNo header line",
				Title = "Markdown Header Test",
				IsSuccess = true,
				UserComment = "Testing header removal"
			}
		};

		// Act
		var result = _generator.GenerateBlogPost(_testDate, promptsWithHeaders, _testDayNumber);

		// Assert
		Assert.That(result, Is.Not.Null);
		Assert.That(result, Does.Contain("> Header 1"));  // # removed
		Assert.That(result, Does.Contain("> Normal text"));  // unchanged
		Assert.That(result, Does.Contain(">   Indented header"));  // # removed, indentation preserved
		Assert.That(result, Does.Contain(">    Multiple hashes"));  // multiple # removed
		Assert.That(result, Does.Contain("> No header line"));  // unchanged
		Assert.That(result, Does.Not.Contain("> # "));  // No # characters should remain
	}
>>>>>>> REPLACE

This test:

  1. Creates a PromptResponsePair with a response containing various markdown header formats
  2. Generates a blog post using this input
  3. Verifies that all header markers (# characters) are removed while preserving indentation
  4. Checks that normal text lines are unchanged

You can run the test with:

cd llm-history-to-post && dotnet test

Tokens: 9.2k sent, 524 received. Cost: $0.04 message, $0.21 session.
Applied edit to llm-history-to-post/tests/Services/BlogPostGeneratorTests.cs
Commit 8c9b9ad test: add test case for markdown header removal in blog post generation
cd llm-history-to-post && dotnet test
Run shell command? (Y)es/(N)o/(D)on’t ask again [Yes]: n
You can use /undo to undo and discard each aider commit.

Verdict: ✅ This didn’t generate all the test cases I wanted, but it did get it to about 99%

Surprised it understood

Prompt:

update that test to have another line that tests that the string " ##Test#Case" is handled correctly

Details

I’ll update the test to include a test case for the string " ##Test#Case". This will verify that multiple # characters in the middle of a line are handled correctly.

llm-history-to-post/tests/Services/BlogPostGeneratorTests.cs

<<<<<<< SEARCH
				Response = "# Header 1\nNormal text\n  # Indented header\n   #Multiple hashes\nNo header line",
=======
				Response = "# Header 1\nNormal text\n  # Indented header\n   #Multiple hashes\nNo header line\n  ##Test#Case",
>>>>>>> REPLACE

llm-history-to-post/tests/Services/BlogPostGeneratorTests.cs

<<<<<<< SEARCH
		Assert.That(result, Does.Contain("> No header line"));  // unchanged
		Assert.That(result, Does.Not.Contain("> # "));  // No # characters should remain
=======
		Assert.That(result, Does.Contain("> No header line"));  // unchanged
		Assert.That(result, Does.Contain(">   Test#Case"));  // ## at start removed, # in middle preserved
		Assert.That(result, Does.Not.Contain("> # "));  // No # characters should remain at start of lines
>>>>>>> REPLACE

These changes:

  1. Add a new line to the test response with " ##Test#Case"
  2. Add an assertion to verify that the ## at the start is removed but the # in the middle is preserved

You can run the test with:

cd llm-history-to-post && dotnet test

Tokens: 10k sent, 324 received. Cost: $0.03 message, $0.24 session.
Applied edit to llm-history-to-post/tests/Services/BlogPostGeneratorTests.cs
Commit 8e5105b test: add test case for handling multiple # characters in markdown headers
cd llm-history-to-post && dotnet test
Run shell command? (Y)es/(N)o/(D)on’t ask again [Yes]: n
You can use /undo to undo and discard each aider commit.

Verdict: ✅ I specifically made the prompt to test whether it could figure out the expected output from the new test input without being told. It did a good job!

Too far

Prompt:

update the test to assert the lines are in the correct order

Details

I’ll update the test to assert that the lines are in the correct order. This will ensure that the markdown header removal doesn’t affect the sequence of lines in the response.

llm-history-to-post/tests/Services/BlogPostGeneratorTests.cs

<<<<<<< SEARCH
		// Assert
		Assert.That(result, Is.Not.Null);
		Assert.That(result, Does.Contain("> Header 1"));  // # removed
		Assert.That(result, Does.Contain("> Normal text"));  // unchanged
		Assert.That(result, Does.Contain(">   Indented header"));  // # removed, indentation preserved
		Assert.That(result, Does.Contain(">    Multiple hashes"));  // multiple # removed
		Assert.That(result, Does.Contain("> No header line"));  // unchanged
		Assert.That(result, Does.Contain(">   Test#Case"));  // ## at start removed, # in middle preserved
		Assert.That(result, Does.Not.Contain("> # "));  // No # characters should remain at start of lines
=======
		// Assert
		Assert.That(result, Is.Not.Null);
		
		// Check for content
		Assert.That(result, Does.Contain("> Header 1"));  // # removed
		Assert.That(result, Does.Contain("> Normal text"));  // unchanged
		Assert.That(result, Does.Contain(">   Indented header"));  // # removed, indentation preserved
		Assert.That(result, Does.Contain(">    Multiple hashes"));  // multiple # removed
		Assert.That(result, Does.Contain("> No header line"));  // unchanged
		Assert.That(result, Does.Contain(">   Test#Case"));  // ## at start removed, # in middle preserved
		Assert.That(result, Does.Not.Contain("> # "));  // No # characters should remain at start of lines
		
		// Check for correct order
		var responseSection = result.Substring(
			result.IndexOf(" tails \"**Response:** (click to expand)\" >}}"),
			result.IndexOf("/ails >}}") - result.IndexOf("{details \"**Response:** (click to expand)\" >}}")
		);
		
		Assert.That(responseSection.IndexOf("> Header 1"), Is.LessThan(responseSection.IndexOf("> Normal text")));
		Assert.That(responseSection.IndexOf("> Normal text"), Is.LessThan(responseSection.IndexOf(">   Indented header")));
		Assert.That(responseSection.IndexOf(">   Indented header"), Is.LessThan(responseSection.IndexOf(">    Multiple hashes")));
		Assert.That(responseSection.IndexOf(">    Multiple hashes"), Is.LessThan(responseSection.IndexOf("> No header line")));
		Assert.That(responseSection.IndexOf("> No header line"), Is.LessThan(responseSection.IndexOf(">   Test#Case")));
>>>>>>> REPLACE

This change:

  1. Extracts the response section from the generated blog post
  2. Adds assertions to verify that each line appears in the correct order relative to the other lines
  3. Uses IndexOf to check the position of each line in the response section
  4. Ensures that the markdown header removal process preserves the original sequence of lines

You can run the test with:

cd llm-history-to-post && dotnet test

Tokens: 10k sent, 664 received. Cost: $0.04 message, $0.29 session.
Applied edit to llm-history-to-post/tests/Services/BlogPostGeneratorTests.cs
Commit 14a1d75 test: add order verification for markdown header removal test
cd llm-history-to-post && dotnet test
Run shell command? (Y)es/(N)o/(D)on’t ask again [Yes]: n
You can use /undo to undo and discard each aider commit.

Verdict: ❌ I flew too close to the sun with this one. I’d rather keep the test the way it was.

Conclusion

A nice diversion! This had an emergent nice workflow where I could pseudo prototype out ideas and pick from my favorite looking implementation. I’d like if I could reduce all ai interactions into a workflow similar to this one.