Managing 37 Issues Across 4 Milestones with Linear: How We Keep AI Projects Organized

Meta Description: We use Linear to track 37 issues across 4 milestones for the Secure AI Prompt Builder course—preventing confusion in long AI conversations and maintaining progress visibility.

Building a complex project with AI across multiple conversations creates a unique problem: context loss. You finish a session, close the tab, come back tomorrow—what was done? What’s next? What’s blocking Milestone 2?

For the Secure AI Prompt Builder course, we’re tracking 37 issues across 4 milestones in Linear. Here’s why we chose Linear, how we use it to prevent confusion, and the workflow that keeps everything on track.

The Problem: AI Conversations Lose Context

Scenario: You’re building a course with Claude. Session 1: You fix test scoring logic. Session 2: You harden 10 prompts. Session 3: You build API key security. By Session 4, you ask: “Wait, did we finish the scoring fix?”

Claude doesn’t automatically remember what was completed three sessions ago. Each conversation is somewhat isolated. Without external tracking, you end up:

• Repeating completed work
• Forgetting blockers
• Losing track of milestone progress
• Asking “what’s left?” every session

Solution: External project tracking that persists across conversations.

Why Linear (Not GitHub Projects, Trello, or Notion)

We evaluated several options:

GitHub Projects

Pros:

• Lives in the repo
• Free for public/private repos
• Markdown support

Cons:

• Limited automation (compared to Linear)
• No GitHub Issues → Linear keyword integration
• UI is clunky for rapid updates

Trello

Pros:

• Simple Kanban interface
• Easy to learn
• Good for visual workflows

Cons:

• No developer-first features
• Limited API (compared to Linear)
• No Git integration
• Not built for technical project management

Notion

Pros:

• Extremely flexible
• Great for documentation + project tracking
• Powerful database views

Cons:

• Overkill for simple issue tracking
• Slower than Linear for rapid updates
• Not built specifically for issue management

Linear (Our Choice)

Why we chose it:

1. Developer-First UX

   • Keyboard shortcuts for everything
   • Fast, native-feeling UI
   • Built by developers, for developers

2. Powerful API

   • Full CRUD via @linear/sdk
   • Programmatic import (37 issues in 60 seconds)
   • Direct integration with Claude via Node.js scripts

3. GitHub Integration

   • Git commit keywords (“Fixes SAPB-20”) auto-close issues
   • Commits linked in Linear activity timeline
   • Bidirectional sync between Linear and GitHub

4. Flexible Workflow States

   • Backlog → Todo → In Progress → Done → Cancelled
   • Custom states if needed
   • Automatic progress tracking

5. Projects (Milestones)

   • Group issues by deliverable
   • Track progress toward each milestone
   • See what’s blocking the next release

Bottom line: Linear is fast, developer-friendly, and integrates seamlessly with our Git workflow.

Our Project Structure

Team: Secure AI Prompt Builder (SAPB)

Milestones (Linear Projects):

1. M1: Testing Complete (10 issues)

   • All 50 prompts tested and hardened
   • Test framework validated
   • Documentation complete

2. M2: Course Ready (12 issues)

   • Course content finalized
   • Platform setup (payment, auth, hosting)
   • Student materials prepared

3. M3: Soft Launch (8 issues)

   • Beta cohort recruited
   • Feedback loop established
   • Initial marketing materials

4. M4: Public Launch (7 issues)

   • Full marketing campaign
   • Support infrastructure
   • Public release

Total: 37 issues across 4 milestones

Labels:

• testing - Test framework and validation
• content - Course materials
• product - Platform features
• launch - Marketing and release
• documentation - Guides and docs

Priorities:

• 🔴 Urgent - Blocking progress (2 issues)
• 🟠 High - Important but not blocking (8 issues)
• 🟡 Medium - Standard priority (20 issues)
• 🟢 Low - Nice to have (7 issues)

How We Use Linear Across AI Conversations

1. Start of Session: Check Current State

Every new conversation starts with:

powershell -File 00-Project-Management/check-all-issues.ps1

Output:

Found 37 issues:

SAPB-1: Fix test scoring logic
  Status: Done
  Priority: 🟠 High
  Comments: 3
  Updated: 12/26/2025, 8:44:37 PM

SAPB-20: API key configuration guide
  Status: Done
  Priority: 🟡 Medium
  Comments: 4
  Updated: 12/28/2025, 9:19:00 AM

SAPB-5: Harden 10 creative prompts
  Status: In Progress
  Priority: 🟠 High
  Comments: 2
  Updated: 12/27/2025, 3:15:00 PM

[... 34 more issues ...]

What this tells us:

• What’s done (SAPB-1, SAPB-20)
• What’s in progress (SAPB-5)
• What’s next (highest priority in Todo)
• What’s blocking milestones

Time to full audit: 30 seconds

2. During Work: Update Status in Real-Time

As we work, we update tickets immediately:

# Starting work on SAPB-5
powershell -File update-issue.ps1 SAPB-5 -Status "In Progress" -Comment "Starting batch 2 of creative prompt hardening"

# Mid-work progress update
powershell -File update-issue.ps1 SAPB-5 -Comment "✅ Hardened 5/10 prompts. Found 23 vulnerabilities so far."

# Completion
powershell -File update-issue.ps1 SAPB-5 -Status "Done" -Comment "All 10 prompts hardened. 47 vulnerabilities fixed total."

Why real-time updates matter:

• Next session sees exactly where we left off
• Comments capture what was done (not just status change)
• No “wait, did we finish that?” confusion

3. Git Commits: Automatic Issue Linking

When work is complete, Git commits automatically close issues:

git commit -m "Harden batch 2 creative prompts (10 prompts)

Fixed 47 vulnerabilities across social-media, ad-copy, and blog-outline prompts.

**Attack types prevented:**
- Jailbreak (19 cases)
- Prompt injection (15 cases)
- Content policy violation (13 cases)

Fixes SAPB-5

🤖 Generated with Claude Code
Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>"

What happens:

1. Commit pushed to GitHub
2. GitHub notifies Linear (via integration)
3. Linear finds “Fixes SAPB-5”
4. Issue automatically marked Done
5. Commit linked in Linear activity
6. Files changed visible in Linear

Result: Zero manual status updates needed.

4. End of Session: Milestone Progress Check

Before ending a session:

# Check progress toward M1
powershell -File check-all-issues.ps1 | grep "M1:"

Output:

M1: Testing Complete - 7/10 issues completed (70%)
  SAPB-1: Done ✅
  SAPB-2: Done ✅
  SAPB-3: In Progress 🔄
  SAPB-4: Todo 📋
  ...

What this tells us:

• How close to milestone completion
• What’s blocking the milestone
• What to prioritize next session

How Linear Prevents Confusion

Problem 1: “What did we accomplish last session?”

Without Linear:

• Re-read previous conversation transcript
• Search for “Done” or “Completed”
• Guess based on Git commits
• Time: 5-10 minutes

With Linear:

• Check issue activity for recent status changes
• See comments with completion notes
• Review commits linked to issues
• Time: 30 seconds

Problem 2: “What’s next?”

Without Linear:

• Scroll through conversation
• Remember what was planned
• Hope nothing was forgotten
• Accuracy: ~70% (frequent forgotten tasks)

With Linear:

• Sort by priority
• Filter by “Todo” status
• See highest priority unstarted work
• Accuracy: 100% (everything is tracked)

Problem 3: “Are we on track for Milestone 2?”

Without Linear:

• Count completed tasks manually
• Estimate progress based on feeling
• No data-driven answer
• Time: Impossible without tracking

With Linear:

• Check project progress (12 issues, 8 done, 4 remaining)
• See 67% completion percentage
• Identify blockers visually
• Time: 10 seconds

Problem 4: “Did we already fix this?”

Without Linear:

• Search conversation history
• Check Git commits
• Ask Claude (who may not remember)
• Risk: High (might redo completed work)

With Linear:

• Search issue titles and descriptions
• Check status (Done = already fixed)
• Read comments for details
• Risk: Zero (definitive source of truth)

The Workflow That Works

Daily Routine:

1. Morning:

   • Run check-all-issues.ps1 to see current state
   • Identify highest priority Todo item
   • Move it to “In Progress”

2. During Work:

   • Update status when starting new issue
   • Add comments with progress notes
   • Change priority if blockers discovered

3. On Completion:

   • Commit with “Fixes SAPB-XX” keyword
   • Verify Linear auto-closed the issue
   • Check milestone progress

4. End of Day:

   • Quick audit of In Progress items
   • Update any stale statuses
   • Plan next session priorities

Time Investment:

• Daily: ~3-5 minutes
• Per session: ~30 seconds (status checks)
• Total: ~10 minutes per week

Time Saved:

• No repeated work: ~20 minutes per week
• No “what’s next?” confusion: ~15 minutes per week
• No milestone tracking manually: ~10 minutes per week
• Total: ~45 minutes per week saved

Net Savings: 35+ minutes per week

Key Lessons Learned

1. External Tracking Is Non-Negotiable for Multi-Session Projects

AI conversations are powerful but ephemeral. Without external tracking:

• Context loss is inevitable
• Repeated work is common
• Progress is invisible

Lesson: If the project spans multiple sessions, use external issue tracking.

2. Real-Time Updates Beat End-of-Session Summaries

We tried two approaches:

Approach 1 (Failed): Update all tickets at end of session

• Forgot what was done
• Comments lacked detail
• Often skipped due to time pressure

Approach 2 (Works): Update tickets immediately during work

• Comments are detailed and accurate
• Nothing forgotten
• Adds ~5 seconds per update

Lesson: Update as you work, not after.

3. Git Integration Reduces Manual Work to Zero

Before GitHub + Linear integration:

• Manual status updates after commits
• Forgot to update Linear
• Stale ticket statuses

After GitHub + Linear integration:

• “Fixes SAPB-XX” auto-closes issue
• Commits linked automatically
• Always up-to-date

Lesson: Automate the meta-work (ticket updates) so you can focus on real work (building).

4. Milestones Provide Progress Visibility

Without milestones:

• “Are we close to launch?” → “Uh, I think so?”
• No clear finish line
• Hard to prioritize

With milestones:

• “Are we close to M1?” → “70% complete, 3 issues remaining”
• Clear deliverables
• Easy prioritization (focus on M1 blockers)

Lesson: Group issues into milestones to track progress toward deliverables.

5. Labels + Priorities Create Focus

37 issues is overwhelming. Filters make it manageable:

Filter by label:

• testing → See all test-related work
• launch → See all marketing/release tasks

Filter by priority:

• 🔴 Urgent → What’s blocking progress?
• 🟠 High → What’s important but not blocking?

Combination:

• testing + 🔴 Urgent → Critical test failures

Lesson: Use labels and priorities to filter noise and focus on what matters.

What’s Next: Advanced Linear Usage

Planned Improvements:

1. Automated Test Results → Linear Comments

   • Failed tests auto-comment on related issues
   • Pass/fail stats updated in real-time
   • Reduces manual test reporting

2. Milestone Progress Tracking

   • Daily summary of progress toward each milestone
   • Slack/email notifications for blockers
   • Automated milestone completion celebration

3. Automated Prioritization

   • Critical failures bump issue priority
   • Stale issues auto-flagged for review
   • Dependencies tracked automatically

4. Release Automation

   • Completed M1 → Trigger course platform deploy
   • Completed M4 → Trigger public launch workflow
   • Zero manual release coordination

Bottom Line

Linear keeps us organized across 37 issues and 4 milestones. Every conversation starts with “What’s the current state?” and ends with “What’s next?” Both answers are instant and accurate.

The Pattern:

• Start session → Check Linear (30 sec)
• During work → Update issues (5 sec each)
• Finish work → Commit with keywords (auto-closes)
• End session → Check milestone progress (10 sec)

Stats:

• 37 issues tracked
• 4 milestones defined
• 0 repeated work
• 0 confusion about status
• ~35 minutes saved per week
• Infinite improvement in progress visibility

Investment: 10 minutes per week Return: Clear priorities, zero confusion, visible progress

Linear isn’t just project management. It’s how we maintain context across AI conversations. And in multi-session AI projects, context is everything.

---

Next post: How we built automated prompt security testing with validated retests—catching vulnerabilities before students see them.