Blog: How we used Claude Code to apply for the Public Benefit Innovation Fund

.github/workflows/trigger-social-post.yml

@@ -0,0 +1,44 @@
+name: Trigger Social Post Creation
+
+on:
+  push:
+    branches: [master]
+    paths:
+      - "src/posts/articles/*.md"
+      - "src/posts/posts.json"
+
+jobs:
+  trigger-social:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 2 # Need previous commit to detect new posts
+
+      - name: Check for new blog posts
+        id: check
+        run: |
+          # Get changed files
+          CHANGED_FILES=$(git diff --name-only HEAD^ HEAD)
+
+          # Check if posts.json was modified
+          if echo "$CHANGED_FILES" | grep -q "src/posts/posts.json"; then
+            # Extract the most recent post (first in array)
+            SLUG=$(python3 -c "import json; posts = json.load(open('src/posts/posts.json')); print(posts[0]['filename'].replace('.md', ''))")
+            TITLE=$(python3 -c "import json; posts = json.load(open('src/posts/posts.json')); print(posts[0]['title'])")
+
+            echo "new_post=true" >> $GITHUB_OUTPUT
+            echo "slug=$SLUG" >> $GITHUB_OUTPUT
+            echo "title=$TITLE" >> $GITHUB_OUTPUT
+          else
+            echo "new_post=false" >> $GITHUB_OUTPUT
+          fi
+
+      - name: Trigger social post creation
+        if: steps.check.outputs.new_post == 'true'
+        uses: peter-evans/repository-dispatch@v2
+        with:
+          token: ${{ secrets.GITHUB_TOKEN }}
+          repository: PolicyEngine/policyengine-social
+          event-type: new_blog_post
+          client-payload: '{"slug": "${{ steps.check.outputs.slug }}", "title": "${{ steps.check.outputs.title }}"}'

src/posts/articles/policyengine-atlas-pbif-grant.md

@@ -0,0 +1,72 @@
+We just completed a $700,000 grant application to USDA's Public Benefit Innovation Fund using an entirely new approach: treating the entire process as a software development project powered by Claude Code. We built not just a grant application but a complete system—50+ pages of content, an interactive demonstration site, and secured partner commitments. Here's how AI transformed grant writing from a document management challenge into a dynamic development process.
+
+## The challenge: 15 complex questions, 250 words each
+
+The PBIF application demanded extreme precision: 15 questions about technical architecture, equity considerations, stakeholder engagement, and sustainability—each limited to exactly 250 words. Traditional grant writing would involve weeks of drafting, editing, and word-counting. Instead, we treated the entire application as a software development project.
+
+## Building with Claude Code: Everything as code
+
+Rather than using Word documents and email chains, we structured everything in Git:
+
+```
+atlas/
+├── docs/pbif/responses/       # 15 markdown files, one per question
+├── scripts/                   # Python scripts to compile and validate
+├── src/components/            # React components for the demo site
+└── public/                    # Interactive demonstration
+```
+
+Every response lived in version-controlled markdown. When reviewers suggested changes, Claude Code would:
+
+- Update the specific response file
+- Regenerate the compiled application
+- Ensure word counts stayed within limits
+- Propagate terminology changes across all documents
+- Update the interactive demo to match
+
+## Real-time iteration with stakeholders
+
+The most powerful moment came during a stakeholder call. As they asked questions like "How would a caseworker actually find documents?", I could say "Let me show you" and have Claude Code generate a working prototype in minutes. The live demo site evolved during the conversation, incorporating feedback immediately.
+
+When someone suggested emphasizing our North Carolina pilot with the Atlanta Fed, Claude Code instantly:
+
+- Found every mention across 50+ files
+- Updated the language consistently
+- Adjusted the demo site's examples
+- Regenerated all compiled documents
+
+## Managing complexity through AI memory
+
+The application grew to include:
+
+- 15 response documents (3,750 words exactly)
+- Partner letters from MyFriendBen, Benefit Navigator, Georgia Center for Opportunity
+- Budget breakdowns across multiple worksheets
+- Technical architecture diagrams
+- An interactive demonstration with three major sections
+
+Claude Code maintained perfect consistency across everything. When we changed "policy library" to "PolicyEngine Atlas", it updated 47 locations automatically. When we adjusted budget allocations, it recalculated totals and updated narrative descriptions simultaneously.
+
+## The revelation: "Everything can be software"
+
+Marc Andreessen's famous "software is eating the world" quote took on new meaning. Grant applications—traditionally the most document-heavy, bureaucratic processes—became fluid, living code. Changes that would trigger days of review became Git commits. Version control replaced email chains. Pull requests replaced track changes.
+
+Most remarkably, treating documentation as code improved quality. The 250-word limit forced clarity. Git's version control captured every iteration. The interactive demo let reviewers experience our vision rather than reading about it.
+
+## Lessons for grant writers and developers
+
+1. **Structure beats process**: Organizing content as discrete, version-controlled files enables parallel work and atomic updates.
+
+2. **Interactive demos convince**: Building a working prototype during the application process demonstrates capability better than any narrative.
+
+3. **AI excels at consistency**: Humans miss inconsistencies across large documents. AI doesn't.
+
+4. **Constraints improve clarity**: The 250-word limit, enforced programmatically, eliminated fluff and forced precise communication.
+
+5. **Everything really can be code**: Even the most traditional documents benefit from version control, automated building, and systematic updates.
+
+## What this means for the future
+
+If AI can transform grant writing—arguably one of the most traditional, document-heavy processes—what else can it revolutionize? We're entering an era where the boundary between "technical" and "non-technical" work dissolves. Writers become developers. Documents become applications. Static PDFs become interactive experiences.
+
+The PolicyEngine Atlas application wasn't just about getting funding. It was a proof of concept that AI-powered development can transform any information-heavy process. When everything becomes software, everything becomes possible.

src/posts/posts.json

@@ -1,4 +1,13 @@
 [
+  {
+    "title": "How we used Claude Code to apply for the Public Benefit Innovation Fund",
+    "description": "Treating writing as software development, we built an entire grant application with interactive demos, perfect consistency, and real-time stakeholder iteration—proving everything can be code.",
+    "date": "2025-08-28",
+    "tags": ["us", "org", "featured"],
+    "filename": "policyengine-atlas-pbif-grant.md",
+    "image": "policyengine-atlas-demo.png",
+    "authors": ["max-ghenis"]
+  },
   {
     "title": "National Science Foundation awards PolicyEngine $300,000 grant",
     "description": "NSF's Pathways to Enable Open-Source Ecosystems program will support PolicyEngine's work to expand access to policy analysis tools.",