I’m turning my attention back to the ai-practitioner-resources repository. This project has been my case study in AI-first software development practices. If you’re not familiar, it started as prompt to return a list of resources relevant to AI assisted software developers. Today it is an AI integrated platform with automated resource curation, AI project management, and a fully autonomous issue lifecycle.

Wide banner illustrating the AI Practitioner Resources repository evolving from a basic static site into an AI-first platform with commit history, modular code, automation workflows, and AI-managed development.
A visual history of the AI Practitioner Resources repository, tracing its evolution from static site to AI-first platform with modular code, workflow automation, and AI-driven project management.

Looking back, i regretted not keeping a more detailed journal of the project’s evolution as I thought it might make for an interesting case study in how AI-first development practices evolve under real usage. Then a prompt occured to me that could write that blog post for me.

Below is that post, as generated by AI.

A project’s git log tells a story that documentation alone cannot. Over 143 commits and four months, the AI Practitioner Resources repository evolved from a single HTML file into an AI-first development platform — one where GitHub Copilot authors commits, AI reviews every incoming issue, and automated workflows manage the entire resource-curation pipeline. This post traces that evolution commit by commit.

The Starting Point: October 29, 2025

The project’s first commit landed at 10:31 AM Pacific on October 29, 2025:

e5b683a 2025-10-29 Add initial HTML and README for AI Practitioner Resources web viewer

Two files. 565 lines. A static HTML page that fetched a JSON resource list from a GitHub Gist and rendered it as a simple card grid. The README described the project’s purpose: a curated collection of AI-powered development resources with a web viewer hosted on GitHub Pages.

Two minutes later, the second commit added the GitHub Actions deployment workflow:

cdf1ecc 2025-10-29 Add GitHub Actions workflow for static content deployment

Within the first three hours, rapid iteration shaped the foundation:

Time Commit Change
12:15 PM 9b73d72 Add JSON schema; restructure HTML for introduction, legend, and analysis sections
12:19 PM ff6f1bf Point GIST_CONFIG to GitHubusercontent URL
12:26 PM 3701574 Add NEW tag styling for recently added resources
12:36 PM 3c2f854 Add blurb property to schema; display resource descriptions
12:40 PM 3695b4c Enhance analysis section styling
12:57 PM 909f82c Update prompts and HTML for formatting consistency

By 1:00 PM on day one, the web viewer was live with schema validation, rich metadata, and visual polish. But the most consequential change of the day was still hours away.

Copilot’s First Commit: The AI-First Paradigm Begins

At 3:54 PM on October 29, GitHub Copilot made its first commit to the repository:

f155ee4 2025-10-29 Copilot — Add automation to create GitHub issues from templates (#1)

This was not a suggestion or auto-complete — it was a full pull request authored by Copilot, implementing a Node.js script that parsed YAML frontmatter from issue templates and created GitHub issues via the API. The PR included rate limiting, duplicate detection, error handling, and validation. Copilot followed up with two more PRs the same afternoon:

9ad8e46 2025-10-29 Copilot — Add footer with GitHub repository links and CODE Magazine attribution (#12)
d58f972 2025-10-29 Copilot — Remove numerical numbering from analysis points (#13)

Then came the automation backbone. Copilot implemented the complete weekly resource-generation pipeline in a single PR:

a51afc1 2025-10-29 Copilot — Implement automated weekly AI resources generation with Gist management (#14)

The diff tells the story — 8,279 lines added across 34 files:

 .github/workflows/weekly-ai-resources-update.yml   |  64 ++
 scripts/fetch-current-resources.js                 | 112 +++
 scripts/generate-resources.js                      | 118 +++
 scripts/merge-and-update.js                        | 108 +++
 scripts/update-gist.js                             | 109 +++
 scripts/validate-schema.js                         | 106 +++
 scripts/create-summary.js                          | 171 ++++
 docs/AUTOMATION_SETUP.md                           | 200 +++++
 docs/IMPLEMENTATION_SUMMARY.md                     | 192 +++++
 package.json                                       |  24 +
 schema.json                                        |  75 ++
 ... (24 more files)
 34 files changed, 8,279 insertions(+), 83 deletions(-)

This single PR introduced the six-stage automation pipeline that still forms the project’s core: fetch current resources from Gist → generate new resources via AI → merge with deduplication → validate against JSON schema → update the Gist → create a summary report.

By the end of day one, the project had established a pattern that would define its identity: human direction, AI implementation.

The AI Model Migration: OpenAI → Anthropic Claude

The evening of October 29 brought a rapid sequence of model changes that reveals a common challenge in AI-integrated systems — finding the right model for the job.

53b5658 2025-10-29 19:03 — Fix OpenAI model: Update from gpt-4-turbo-preview to gpt-4
4d5d8c8 2025-10-29 19:09 — Update OpenAI model to gpt-3.5-turbo
00203c7 2025-10-29 20:09 — Improve JSON parsing robustness in generate-resources.js
3074b42 2025-10-29 20:12 — Add robust JSON parsing with multiple fallback strategies
c35748f 2025-10-29 20:30 — Enhance automation to generate comprehensive real resources
0fb1fee 2025-10-29 20:36 — Migrate from OpenAI to Anthropic Claude API
dff5988 2025-10-29 20:51 — Upgrade to Claude Sonnet 4.x model

Within two hours, the project went from GPT-4 to GPT-3.5-turbo (likely for cost or reliability), then abandoned OpenAI entirely in favor of Anthropic’s Claude API. The migration diff shows the API endpoint and authentication pattern change:

-    const response = await fetch('https://api.anthropic.com/v1/messages', {
-      method: 'POST',
+    const response = await fetch("https://api.anthropic.com/v1/messages", {
+      method: "POST",
       headers: {
-        'x-api-key': ANTHROPIC_API_KEY,
-        'anthropic-version': '2023-06-01'
+        "x-api-key": ANTHROPIC_API_KEY,
+        "anthropic-version": "2023-06-01",
       },
       body: JSON.stringify({
-        model: 'claude-3-5-sonnet-20241022',
-        max_tokens: 8000,
+        model: "claude-sonnet-4-20250514",
+        max_tokens: 10000,

The JSON parsing commits (00203c7, 3074b42) are revealing — AI-generated JSON often needed fallback strategies to handle malformed output. This practical problem drove the addition of multiple extraction methods to handle responses that included markdown fences, trailing text, or incomplete objects.

Day Three: Production Polish and the UI Redesign (October 31)

October 31 brought a series of production-readiness commits:

fafaafd 2025-10-31 — feat: Complete UI redesign with risk-based scoring system
750bc58 2025-10-31 — feat: Enhance automation pipeline with Claude Sonnet 4 integration
f30e819 2025-10-31 — refactor: Refine AI prompts and schema for better resource generation
1a819af 2025-10-31 — feat: Configure production setup and update automation results
2a3aadd 2025-10-31 — chore: Clean up workspace and organize project structure

The UI redesign was substantial — 994 lines removed and 57 added in index.html alone — replacing the initial layout with a risk-based scoring system that evaluated resources against seven principal risks of AI-assisted coding:

  1. Security Vulnerabilities
  2. Logic and Quality Issues
  3. Data Leakage and Confidentiality
  4. Licensing and IP Concerns
  5. Maintainability and Traceability
  6. Bias and Inconsistent Standards
  7. Over-Reliance and Skill Atrophy

Each resource received individual scores (60–100) across these risk dimensions. The schema evolved from a simple score field to a structured risk_coverage object with per-risk scoring.

The same day established the project’s domain and contribution model:

5a0321c 2025-10-31 — feat: Add custom domain configuration and update workflow schedule
7ec000e 2025-10-31 — feat: Update CNAME to point to ai-resources.codemag.com
2031d70 2025-10-31 — feat: Add CONTRIBUTORS.md and update contribution guidelines
c7d9441 2025-10-31 — feat: Add JSON-specific prompt for AI Practitioner Resources
2f0e579 2025-10-31 — feat: Add markdown-first issue creation process

The CONTRIBUTORS.md established a radical policy: no traditional pull requests accepted. Contributors submit issues with detailed prompts; approved issues are assigned to GitHub Copilot for implementation. The project was explicitly an experiment in AI-first development.

The Modularization: Copilot Refactors a Monolith (November 3)

By November 3, index.html had grown to 1,155 lines — all HTML, CSS, and JavaScript in a single file. Copilot performed a comprehensive refactoring in PR #43:

da7b837 2025-11-03 Copilot — Extract testable modules from 1,155-line monolithic HTML structure (#43)

The result: 23 files changed, 4,297 lines added, 1,017 removed. The monolith was decomposed into a clean ES6 module architecture:

src/
├── app.js                    # Main coordinator (89 lines)
├── core/
│   ├── colors.js             # Color calculations (49 lines)
│   ├── filters.js            # Filtering logic (58 lines)
│   └── data-processor.js     # Data transformations (75 lines)
├── services/
│   ├── api.js                # GitHub Gist API (64 lines)
│   └── storage.js            # LocalStorage abstraction (76 lines)
├── components/
│   ├── resource-card.js      # Resource cards (87 lines)
│   ├── filter-panel.js       # Filter buttons (49 lines)
│   ├── stats.js              # Statistics (39 lines)
│   ├── introduction.js       # Introduction section (46 lines)
│   ├── legend.js             # Legend/methodology (14 lines)
│   ├── analysis.js           # Weekly analysis (61 lines)
│   └── modal.js              # Modal dialogs (42 lines)
├── utils/
│   ├── dom.js                # DOM helpers (85 lines)
│   └── constants.js          # Configuration (90 lines)
└── README.md                 # 324 lines of documentation

Average module size dropped to 68 lines. Every function stayed under 20 lines. The refactoring introduced Vitest as a test framework, with 34 passing tests covering core logic, services, and components. The accompanying REFACTORING_SUMMARY.md documented zero security vulnerabilities from CodeQL scanning.

The same day, Copilot set up repository-wide instructions (33725ea) and performed a comprehensive analysis of all 22 open issues with prioritization recommendations (03fb37b).

The Project-Management Pipeline: AI Reviews AI (November 4–11)

The most architecturally ambitious phase began on November 4. Over eight days, the project built a complete AI-powered project-management system.

Phase 1: Issue Intake and PM Review (November 4)

The work started with infrastructure for managing issues through GitHub Projects v2:

05298bc 2025-11-04 — Refactor issue intake and lane management to utilize Project 1 Status
def6427 2025-11-04 — Enhance issue intake workflow to optionally manage Project item status
9fa7586 2025-11-04 — Refactor issue intake workflow for user-level Projects v2 with PAT
77927e8 2025-11-04 — fix(intake): prefer TOKEN (PAT) over GITHUB_TOKEN for Projects v2

Then came the AI PM review — a workflow that triggers when any issue is opened, sending the issue content to an AI model for structured analysis:

5aa7945 2025-11-04 — feat(intake): add Copilot PM review on issue open using OpenAI

Within hours, the PM review migrated from OpenAI to Anthropic (following the same pattern as the resource generator):

d74c2d9 2025-11-04 — chore(pm-review): migrate from OpenAI to Anthropic Messages API
084fe95 2025-11-04 — feat(pm-review): update model to claude-4.5-sonnet-latest
815c5be 2025-11-04 — chore(workflow): pin PM model to claude-sonnet-4-5-20250929

The PM review system posts structured checklists to issues, assigns contributors, manages lane assignments (at bat / on deck / in the hole / on the bench), and can even split large issues into sub-issues.

Phase 2: Session Management (November 4)

7dc3dc1 2025-11-04 — feat: Implement session management for GitHub Copilot

This addressed a fundamental limitation: Copilot does not persist context across conversations. The session-management system automatically captures full implementation context when Copilot creates a PR — original issue details, decision rationale, modified files, commit history — and restores it when Copilot needs to address review feedback. This enabled genuine multi-turn implementation loops.

Phase 3: Issue Lifecycle Test Automation (November 5)

The copilot-swe-agent[bot] authored a batch of commits implementing comprehensive lifecycle testing:

8d467fb 2025-11-05 copilot-swe-agent[bot] — Add comprehensive issue lifecycle test automation script
9c7e270 2025-11-05 copilot-swe-agent[bot] — Add shell script, workflow, and execution guide
4d172cf 2025-11-05 copilot-swe-agent[bot] — Add comprehensive test documentation and quick reference
1805712 2025-11-05 copilot-swe-agent[bot] — Add master README for test automation suite
0409c8a 2025-11-05 copilot-swe-agent[bot] — Complete issue lifecycle test automation with execution report

The test suite covers 12 scenarios, 7 gates, 20+ states, and 30+ transitions — validating the entire lifecycle from issue creation through PM triage, lane assignment, PR workflow, code review, and closure with automated rebalancing.

A complete state machine diagram documents the lifecycle:

Issue Created → Auto Validation → Backlog → PM Triage → Lane Assignment
    → At Bat → Copilot Branch → PR Created → AI Code Review → AC Check
    → CI/CD → Human Review → Merge → Issue Closed → Lane Rebalance

Phase 4: PM Review Refinement (November 11)

November 11 was the most commit-dense day in the project’s history, with 25+ commits focused entirely on hardening the PM review system:

91afe93 — Add automatic sub-issue creation for large issues in PM review
514db19 — Add intelligent issue reformatting with context-aware suggestions
5f2a89f — Enhance issue reformatting to support all template types
80b51d3 — Enhance PM review prompt to ensure needsSplit triggers sub-issue creation
d56596c — Add explicit JSON examples for needsSplit in PM review prompt
82c342e — Add debug logging to PM review JSON parsing
0f32b7d — Enforce strict JSON schema in PM review prompt
3a1bb72 — Add JSON normalization to handle missing required fields
b9d5488 — Extract PM review schema into separate JSON Schema file
e094540 — feat: implement schema validation and pre-framing based on successful resources generation

The pattern is unmistakable: each commit addresses a specific failure mode discovered during real usage. AI-generated JSON had missing fields — add normalization. Sub-issues returned as strings instead of objects — add type coercion. The PM prompt did not reliably trigger issue splitting — add explicit JSON examples. This is pragmatic, test-and-fix evolution driven by production behavior.

The Workflow Architecture: Nine Automated Pipelines

By mid-November, the repository had accumulated nine GitHub Actions workflows:

Workflow Trigger Purpose
static.yml Push to main Deploy GitHub Pages
weekly-ai-resources-update.yml Cron (Monday 9 AM UTC) + manual Generate and publish resources
issue-intake.yml Issue opened Auto-validate + AI PM review
rebalance-on-close.yml Issue closed Rebalance project lanes
ai-code-review.yml PR opened/updated Multi-round AI code review
capture-copilot-session.yml PR from copilot/* branch Save implementation context
handle-copilot-review-changes.yml PR review with changes requested Restore context for Copilot
create-issues.yml Manual Batch-create issues from templates
test-issue-lifecycle.yml Manual Run lifecycle test suite

Together, these workflows form a closed loop: issues flow in, AI triages them, Copilot implements solutions, AI reviews the code, and on closure, the project board rebalances automatically.

The Quiet Period and the Refresh (December 2025 – February 2026)

After the intense November buildout, the commit frequency dropped. December 28 brought a cleanup:

76742cb 2025-12-28 — refactor: remove deprecated PM mode files and simplify intake workflow
198aa54 2025-12-28 — Automated commit of changes in automation-results

January 2026 saw minor maintenance — adding .clockwork.json to .gitignore, merging branches, and removing a footer section from index.html.

February 2026 marked a renewed focus on the resource-generation pipeline:

670e858 2026-02-20 — chore: update dependencies and refactor resource generation scripts
71157d0 2026-02-20 — Deploy to test environment: Add metadata tracking and environment-specific gist filenames
d10477b 2026-02-20 — chore: update resource generation and merge scripts with new prompt template
ed3b588 2026-02-24 — feat: add configurable resource count and update mode support

The February work introduced environment-specific gist filenames (separating test from production), metadata tracking, a configurable resource count, and updated prompt templates. The DETERMINISM_GUIDE.md added during this period documents temperature controls and stability-focused prompting to improve consistency across generation runs:

The AI generation now uses a configurable temperature parameter to control output randomness. Default: 0.3 (balanced determinism). The prompt has been enhanced to prioritize stable, authoritative resources — OWASP, NIST, AWS, Azure, Google Cloud, O’Reilly, Manning. The merge script now uses flexible matching to handle URL and title variations.

By the Numbers

Metric Value
First commit October 29, 2025
Most recent commit February 24, 2026
Total commits 143
Human-authored commits 122
Copilot-authored commits 11
copilot-swe-agent[bot] commits 10
Unique authors 3 (human) + 2 (AI)
GitHub Actions workflows 9
Automation scripts 13+
Lines in initial commit 565
Lines after modularization 4,297 added in one PR

Commit Authorship: Human and AI

The commit log records five distinct author identities:

Author Commits Role
john Michael Miller / John Miller / John Michael Miller 122 Project maintainer — direction, integration, debugging
Copilot 11 PR-based implementations from GitHub Copilot
copilot-swe-agent[bot] 10 Autonomous agent implementations on branches

The human commits cluster around architecture decisions, model migrations, prompt refinement, and production debugging. The AI commits cluster around feature implementation, documentation generation, and test automation — precisely the pattern the CONTRIBUTORS.md prescribes.

What the Git Log Reveals

Three patterns emerge from this history:

Rapid model churn stabilizes quickly. The October 29 evening session shows four model changes in two hours (GPT-4 → GPT-3.5 → Claude 3.5 → Claude Sonnet 4). The PM review repeated the same migration on November 4. After that, the model choices stabilized. AI-integrated projects should expect this early turbulence and plan for API abstraction.

AI-generated output requires defensive parsing. Multiple commits across both the resource generator and the PM review system add JSON normalization, fallback extraction strategies, type coercion, and schema enforcement. When AI generates structured data, the consuming code must assume the output will be subtly wrong in ways that evolve as models update.

Human effort shifts from writing code to designing systems. The majority of the 122 human commits are not traditional “write a feature” commits. They are prompt refinements, schema updates, workflow configurations, model migrations, and integration debugging. The code itself is increasingly AI-authored; the human work is architectural and operational.

The Current State

As of March 2026, the AI Practitioner Resources repository is:

  • A live website at ai-resources.codemag.com serving curated AI development resources
  • An automated content pipeline that generates, validates, and publishes new resources weekly using Claude Sonnet 4
  • An AI-managed project board where every incoming issue receives AI PM review, lane assignment, and — if needed — automatic splitting into sub-issues
  • A modular ES6 application with 13 focused JavaScript modules, separated CSS, and a Vitest test suite
  • An experiment in AI-first development with a documented contribution model that routes all implementation through GitHub Copilot

The project’s own CONTRIBUTORS.md states its philosophy plainly:

This project serves as an experiment in AI-first development, where human contributors provide high-level direction and ideas, AI agents handle the implementation details, code reviews focus on prompt quality and outcomes, and community input drives feature prioritization.

143 commits later, that experiment continues.

What’s Next?

The resource-generation pipeline’s February 2026 updates point toward further determinism and reliability improvements. The test/production environment separation suggests a maturing operational posture. The project’s trajectory — from static HTML to autonomous AI pipeline in four months — offers a concrete case study in how AI-first development practices evolve under real usage.

Feedback Loop

Feedback is always welcome. Send your thoughts to AIPR@pdata.com.

Disclaimer

AI contributed to the writing of this post, but humans reviewed it, refined it, enhanced it, and gave it soul.

Prompts:

  • Review the full git log of ai-practitioner-resources with dates and authors to establish a project timeline
  • Examine key diffs (first commit, Copilot’s first PR, OpenAI→Claude migration, modularization, PM review pipeline) to quantify change scope
  • Read all project documentation (README, CONTRIBUTORS, DEV_NOTES, REFACTORING_SUMMARY, IMPLEMENTATION_SUMMARY, DETERMINISM_GUIDE, SESSION_MANAGEMENT_README, QUICK_REFERENCE, scripts/README) for architectural context
  • Draft a chronological blog post following AIAGSD series conventions with evidence from git history