DEV Community: Akira Hayashi (rin)

Building a GitHub Action for Recurring Project Items

Akira Hayashi (rin) — Sun, 09 Nov 2025 17:32:51 +0000

Quick notes on building an automation tool.

What I Built

GitHub Action "recurring-backlog-item-creator"

The YAML config tells the whole story:

defaults:
  project_id: "PVT_kwHOAOKHl84BHgin"
  target_repo: "Rindrics/recurring-backlog-item-creator"
issues:
  - name: "Wash My Cat"
    template_file: ".github/ISSUE_TEMPLATE/wash_my_cat.md"
    creation_months: [1, 3, 5, 7, 9]
    title_suffix: "- {{YearMonth}}"
    fields:
      Priority: "P1"
      Status: "Ready"
  - name: "Buy New Shoes"
    template_file: ".github/ISSUE_TEMPLATE/buy_shoes.md"
    title_prefix: "[{{Year}}]"
    title_suffix: "- ({{Month}})"
    creation_months: [3, 11, 12]
    fields:
      Priority: "P2"
      Status: "Backlog"
    project_id: "PVT_XXXXX"  # you can override the default project_id
    target_repo: "Rindrics/other-repo"  # you can override the default target_repo

The link below will also helpful to understand this action:

execution result (GitHub project board): https://github.com/users/Rindrics/projects/41
user workflow example: https://github.com/Rindrics/recurring-backlog-item-creator/blob/main/.github/workflows/test-workflow.yml

Background and Reflection

Creating issues periodically from templates is a common use case.
However, GitHub's existing features become cumbersome when you need:

Different creation intervals for each issue
Dynamic prefixes/suffixes like [yyyy-MM] in titles
Adding issues to projects while setting custom field values

For these requirements, a config file like this solves the problem.

In this action, the core functionality became filtering and validation of the config file
because GitHub GraphQL API enables easy issue creation and project registration.

So I built a tool focused on filtering and validation, implemented in Go.

What Went Well

Validation ensures the action fails if you specify non-existent fields or values in the target project.
This makes it safe to use with confidence.

The config file being self-documenting is also a subtle advantage --- you can see what it does at a glance.

Also, tagpr - thank you as always!

What Could Be Better

I initially organized the code by role within a single main package, thinking it wouldn't grow much.
Even at this scale, changes scattered across multiple files made it somewhat difficult to work with.

To improve cohesion, I only know approaches like port-adapter architecture, which feels like overkill for a tool of this size.
I still don't have a good intuition for the right balance.

The downsides of a single-package structure were minimal.
The simplicity seemed to outweigh any drawbacks.

Where I Got Stuck

Accessing user GitHub projects requires a PAT...!

Until I realized this, I was using a GitHub App token with Project.write repository permission.
This permission likely belongs to the deprecated projects (classic) feature¹, and I burned about 3 hours on this...

Future Plans

At v1.0, the filter condition is "month" only, but it could be extended to support "year," "day," and "day of week."

 - name: "Wash My Cat"
    template_file: ".github/ISSUE_TEMPLATE/wash_my_cat.md"
    creation_months: [1, 3, 5, 7, 9, 11]
    creation_day: [10, 20, 30]
    creation_day_of_week: ["Mon"]

With this config, issues would be created on odd-numbered months, on days ending in 0, if they fall on Monday.
For such granular conditions, you'd probably set the cron to run daily.

Probably. Reading here and here suggests so. ↩

Think Like a Detective: Why Hypothesis Testing Beats Raw Coding Skills

Akira Hayashi (rin) — Mon, 17 Feb 2025 15:34:30 +0000

Your code isn't working... what do you do?
You might think, "I need to improve my coding skills... what books should I read?"
However, what you actually need is a problem-solving approach, particularly hypothesis testing thinking.

Coding Skills are Secondary

Writing programs requires two main abilities:

Coding skills: writing code that follows proper syntax and function usage
Problem-solving ability: constructing logical pathways to solve the problems at hand

For programming beginners, coding feels very much like "real programming," making it the most visible target for improvement.
This often leads newcomers to attribute their problems to insufficient coding skills ── but here lies a major pitfall.

While coding ability is related to "knowledge volume," the programming world is so vast and deep that you'll rarely feel you have sufficient knowledge for the task at hand.
Problem-solving ability, on the other hand, lets you acquire necessary knowledge on the spot and move forward, even when your knowledge is incomplete.

Common Mistakes Beginners Make When Facing Errors

From my experience working with programming beginners, here are the most common patterns I've observed:

Pattern 1: Not noticing upstream errors and getting stuck on downstream issues 😢
Pattern 2: Complete mental shutdown at the sight of an error without reading the message 😢
Pattern 3: "Imagining" the problem based on a few keywords in the error message and making changes based on that imagination 😢
Pattern 4: Understanding the error message but attempting fixes without identifying the root cause 😢

These are arranged from most to least problematic, not by frequency.
Pattern 1 is the worst but relatively rare.

Pattern 2 is common among absolute beginners and usually evolves into Pattern 3 with experience.
Both can be addressed by "reading the error message carefully," but it often takes time for beginners to realize that error messages are allies, not enemies, in problem-solving.

Pattern 3 might occasionally lead to successful fixes by trial and error, but it's important to recognize these as lucky accidents rather than proper problem-solving.

Pattern 4 might seem reasonable and often works, but skipping root cause analysis can lead to deep trouble in complex situations. Even experienced programmers sometimes fall into this pattern.

Basic Steps of Problem Solving

Here's the systematic approach to solving any programming problem:

Problem Identification ✅
- Verify the current state of the system and environment
- Clearly define what's going wrong
- Sometimes includes hypothesis testing to confirm problem identification
Hypothesis Formation ✅
- Theorize what changes might solve the problem
Hypothesis Testing ✅
- Verify if the changes actually solved the problem

While some steps might be abbreviated depending on the situation, this is the fundamental flow to follow.

When unexpected results occur, even in seemingly simple problems, it's worth returning to earlier steps for careful verification.

If your hypothesis in step 2 proves wrong, that's not a failure: it's progress!
You've eliminated one possibility and gained knowledge for forming your next hypothesis.

Thought Experiment: Would Outsourcing the Coding Help?

Consider this: what if you could delegate all coding to a super-programmer?
Even with technical implementation concerns removed, without problem-solving skills, you couldn't even specify what needs to be investigated to understand the current situation.

You might be able to request code changes directly (bad "Pattern 4"), but without proper problem analysis, these requests could be completely off-target.
Superior coding ability alone doesn't help here.

Conclusion

The most crucial element in programming problem-solving isn't technical coding ability: it's the capacity to systematically understand problems and test hypotheses.

This skill extends far beyond programming ── it's vital for any professional work, and arguably, for steering your own life course.
But you probably knew that already 👍

Lightweight, Transparent, Animated: Get All of Them by WebP Format

Akira Hayashi (rin) — Mon, 16 Dec 2024 17:21:46 +0000

Introduction

Image optimization remains one of the most effective strategies for web performance optimization. WebP, developed by Google as a successor to JPEG and PNG, is an innovative image format that significantly reduces file size while maintaining visual quality. Let's dive into why you might want to consider WebP for your next project.

What is WebP?

WebP is an image file format based on the Resource Interchange File Format (RIFF) that supports lossless and lossy compression as well as alpha (transparency) and animation. ────RFC 9649¹

Developed by Google in 2010², it's designed to deliver superior compression for images on the web.
Here's what makes it special:

Supports both lossless and lossy compression
Handles alpha channel transparency
Supports animation sequences
Delivers superior compression (25-34% smaller files compared to JPEG on average)

Real-world Benefits

1. Performance Boost

While we often focus on code optimization, images typically constitute the largest portion of a web page's total size.
WebP addresses this directly:

Faster page load times
Reduced bandwidth consumption
Lower data usage for mobile users (your users will thank you!)

2. Quality-Size Sweet Spot

One of WebP's most impressive features is its ability to maintain high image quality while significantly reducing file size:

Delivers equal or better quality than JPEG at smaller sizes
Works well for both photographs and illustrations
Particularly effective for large, high-quality images

3. Format Consolidation

WebP can potentially replace multiple legacy formats:

Combines the best of PNG (transparency) and JPEG (photo compression)
Can replace animated GIFs with much smaller file sizes
Reduces complexity in image management workflows

Considering these benefits, WebP is particularly valuable for
situations below:

E-commerce sites with numerous product images
Global web applications where bandwidth varies
Content-heavy sites with significant image usage
Mobile-first applications
Performance-critical web applications

Example Usage on Command Line

The cwebp command makes it easy to perform the conversion to .webp format as follows³:

# Lossy conversion with quality maintained at 80%
cwebp input.jpg -q 80 -o output.webp

# Lossless conversion (best for screenshots/diagrams)
cwebp input.png -lossless -o output.webp

Adoption Challenges

Despite its benefits, WebP hasn't achieved universal adoption yet. There may be the possible reasons:

Browser Support Evolution
- While major modern browsers now support WebP, ~legacy browser~ IE support requires fallback images⁴
- Safari (iOS) only added support in 2020
- Some older enterprise systems may still use incompatible browsers
Awareness Gap
- Many developers still default to familiar formats like JPEG and PNG (I didn't know either 🫣)
- Limited support in popular image editing software
- Learning curve for implementation and tooling
Implementation Overhead
- Requires converting existing image assets
- Need to set up build processes for automatic conversion
- Additional complexity in serving fallback images

Moving Forward: Implementation Strategy

Ready to implement WebP? Here's a practical approach:

Start with New Projects
- Implement WebP in new projects where you have full control
- Set up automated conversion in your build pipeline
Gradual Migration for Existing Projects
- Begin with high-impact images (large, frequently accessed)
- Use progressive enhancement with fallbacks
- Monitor bandwidth savings and user experience metrics

Conclusion

WebP represents a significant step forward in web image optimization. With broad browser support now available and clear performance benefits, it's becoming an increasingly attractive option for modern web development.

As web performance continues to impact user experience and SEO rankings, adopting WebP can give your applications a competitive edge. The initial setup effort is justified by the long-term benefits in performance and user experience.

RFC9649 ↩
Today, this information can only be accessed by using a web archive ↩
Document by Google ↩
Browser support ↩