After six months of iterative refinement, I've built a collection of over 50 Warp rules that have fundamentally changed how I interact with my terminal. What started as a few convenience shortcuts has evolved into a comprehensive system that anticipates my needs, enforces best practices, and eliminates countless micro-frustrations throughout my day.

In this post, I'll share the most impactful rules from my collection, explain how they work together to create compounding benefits, and provide practical tips for building your own intelligent terminal workflow.

What Are Warp Rules?

Before diving into specifics, let's clarify what Warp rules actually are. Warp is an Agentic Development Environment: think prompt-native coding with AI agents and persistent ‘rules’ that customize how the assistant responds to your commands.

Think of rules as teaching your terminal about:

• Your specific environment and tool preferences
• Project-specific conventions and workflows
• Personal coding standards and best practices
• Common tasks and their optimal execution patterns

Unlike traditional shell aliases or functions, Warp rules provide contextual intelligence that adapts to your current situation, making your terminal feel less like a command executor and more like a knowledgeable pair programmer.

The Rules That Save Me Hours Every Week

1. Intelligent Git Workflow Orchestration

My git-related rules form the backbone of my development workflow. Beyond simple aliases (ga for git add, gc for commit, gp for push), I've implemented a comprehensive commit management system:

Rule: "After every major change, commit with multiline conventional commit syntax"
Rule: "Check git status after file-changing commands"
Rule: "Pull before making changes in a new session"
Rule: "Use forgit for interactive log browsing"

The real magic happens when these rules work together. When I complete a feature, my terminal:

1. Automatically suggests staging relevant files
2. Generates a properly formatted conventional commit message with emojis
3. Creates commits that serve as "save points" (inspired by video games)
4. Ensures I never lose work to accidental overwrites

Impact: I estimate this saves me 30 minutes daily just in git operations and has prevented numerous "oh no" moments where I've accidentally overwritten uncommitted changes.

2. The Morning Routine Automation

One of my favorite productivity rules kicks in automatically when I open a new terminal:

Rule: "When a new terminal window is opened, run the Morning Routine workflow: ws && wc"

This simple rule:

• Navigates to my workspace
• Clears any leftover context
• Sets up my environment for the day
• Displays my task list and priorities

Impact: Starting each day with a clean, organized terminal session has improved my morning productivity by at least 20%.

3. Project Initialization Intelligence

Starting new projects used to involve a checklist I'd invariably forget parts of. Now, my rules handle everything:

Rule: "When beginning a new project:
  - Check for existing git repo
  - Create one if needed with proper .gitignore
  - Rename master to main
  - Create Implementation Status Log
  - Set up GitHub remote repo
  - Initialize appropriate documentation structure"

The Implementation Status Log rule deserves special mention—it automatically creates a structured tracking document with:

• Unique task identifiers
• Status indicators (TODO, IN PROGRESS, TESTING, DONE, BLOCKED)
• Priority levels
• Dependencies
• Assignment tracking

Impact: Project setup time reduced from 30 minutes to under 5 minutes, with perfect consistency.

4. The Clever ls Lolcat Workaround

This might seem trivial, but it perfectly illustrates how rules solve real friction points:

Rule: "ls is aliased to lolcat for colorized output. Use \ls for actual ls functionality"

I love my colorful terminal output (powered by lolcat), but it breaks complex ls commands. Instead of constantly remembering to escape the command or dealing with errors, my AI assistant automatically knows when to use \ls versus the aliased version.

Impact: Eliminates 10-15 daily micro-frustrations that compound into significant mental overhead.

5. Memory System Integration

I use multiple knowledge management tools, and my rules create a seamless integration layer:

Rule: "Use basic-memory for significant context that should persist across sessions"
Rule: "Store in 'memory' project with proper categorization"
Rule: "Access context docs via Obsidian MCP in programming/MCPs/context-docs/"

This creates a personal knowledge base that grows automatically as I work, capturing:

• Project decisions and rationale
• Technical insights and learnings
• Code patterns and solutions
• Team knowledge and processes

Impact: Reduced time searching for "how did I solve this before?" from hours to seconds.

6. Context Management with Pieces MCP

While my memory system captures explicit knowledge, I've supercharged my contextual awareness using Pieces MCP—a tool that automatically indexes everything I do across applications:

Rule: "Use Pieces MCP to capture cross-application context"
Rule: "Query Pieces for recent activity when starting complex tasks"
Rule: "Create Pieces memories for significant breakthroughs"

Pieces is like having a photographic memory of my entire development workflow. It captures:

• Terminal sessions: Every command I run in Warp, with output and timing
• Browser research: Stack Overflow searches, documentation reads, GitHub browsing
• Communication context: Slack discussions, Linear issues, Discord threads
• AI interactions: Claude conversations, Perplexity searches, debugging sessions

The real power comes from how Pieces connects these disparate activities. Here's a real example from last week:

The Authentication Bug Journey

1. 9:15 AM: Slack message about authentication failures
2. 9:20 AM: Browsed three Stack Overflow threads about JWT token expiration
3. 9:35 AM: Ran grep -r "token_expiry" ./src in Warp
4. 9:40 AM: Opened auth middleware in Cursor
5. 9:45 AM: Asked Claude about refresh token best practices
6. 10:00 AM: Fixed the bug and pushed to production

Without Pieces, reconstructing this workflow would require checking multiple tools. With my Pieces rules, I can query:

{
  "question": "How did I fix the authentication bug?",
  "chat_llm": "claude-3-5-sonnet-20241022",
  "application_sources": ["Warp", "Chrome", "Slack", "Claude"],
  "topics": ["authentication", "JWT", "token expiry"]
}

And get a complete timeline with context, including the exact commands, searches, and solutions.

Workflow Enhancement Examples

"What was I working on before lunch?"

• Pieces shows: Terminal commands, browser tabs, file edits
• Time saved: 5-10 minutes of mental reconstruction

"How did I solve this similar problem last month?"

• Pieces retrieves: Related searches, terminal history, successful solutions
• Time saved: 30+ minutes of searching through logs and history

"What did the team discuss about this feature?"

• Pieces connects: Slack threads → browser research → implementation
• Context switching reduced: 70% fewer tool switches

The combination of Warp rules and Pieces MCP creates an augmented memory system where:

• Nothing important is forgotten
• Context is always available
• Patterns emerge from historical data
• Debugging becomes archaeological rather than exploratory

Impact: 40% reduction in "context reconstruction time" when returning to complex problems. Average debugging time reduced by 25% due to better historical context.

7. Intelligent Code Editor Integration

When editing code, my rules automatically invoke specialized tools:

Rule: "Use serena for LSP capabilities when editing code"
Rule: "Maintain separate concerns in different files to avoid token limits"
Rule: "Take changes step by step to prevent token overflow"

This ensures that:

• Code modifications happen with full language server support
• Large changes are broken into manageable chunks
• Version control captures each logical step

Impact: Cleaner commit history and 50% reduction in failed AI operations due to context limits.

8. Security and Best Practices Enforcement

My rules act as an automatic security linter:

Rule: "Maintain best security practices on production-grade apps"
Rule: "Never use interactive or fullscreen shell commands"
Rule: "Bias strongly against unsafe commands unless explicitly required"

These rules have prevented me from:

• Accidentally running dangerous commands
• Committing sensitive data
• Using insecure coding patterns
• Executing potentially harmful scripts

Impact: Zero security incidents in six months, despite working with multiple production systems.

9. Documentation Generation and Maintenance

Documentation often becomes stale, but my rules keep it current:

Rule: "Build and maintain effective documentation based on project complexity"
Rule: "Update Implementation Status Log with every major change"
Rule: "Create and maintain task lists for complex projects"

The system automatically:

• Generates appropriate documentation templates
• Updates status logs after commits
• Creates README files with proper structure
• Maintains API documentation
• Links related documents in my knowledge base

Impact: Documentation is always current, saving hours in team onboarding and reducing "what was I thinking?" moments.

10. Google Apps Script Specialized Workflow

As someone who frequently works with Google Apps Script, I've created targeted rules:

Rule: "In GAS projects, ensure type definitions are installed"
Rule: "Configure .claspignore with appropriate patterns"
Rule: "Add WARP.md to claspignore automatically"

These rules eliminate the repetitive setup tasks that plague GAS development, ensuring:

• Type safety from the start
• Proper file exclusions
• Consistent project structure

Impact: GAS project setup reduced from 15 minutes to instant.

11. Intelligent Search and Navigation

My rules optimize how I search through codebases:

Rule: "Use ripgrep (rg) instead of grep for large filesystems"
Rule: "Prefer grep tool for exact symbol searches"
Rule: "Use search_codebase for semantic queries"

This creates a hierarchy of search strategies:

1. Exact matches with ripgrep for speed
2. Semantic searches when I don't know exact terms
3. Contextual navigation based on project structure

Impact: Finding code reduced from minutes of grepping to seconds of intelligent searching.

How Rules Compound Into Superpowers

The true power of Warp rules isn't in any single rule—it's in how they work together to create emergent workflows. Here's a real example from last week:

1. I opened a new terminal (morning routine activated)
2. Started a new project (initialization rules triggered)
3. Made my first changes (git rules suggested initial commit)
4. Encountered a complex problem (memory system captured solution)
5. Needed to search similar patterns (intelligent search found precedents)
6. Completed feature (documentation automatically updated)
7. Pushed to production (security rules validated everything)

What would have been a series of manual steps, each with potential for error or omission, became a smooth, guided flow where my terminal anticipated and facilitated each transition.

Project-Specific Rules: The Secret Sauce

Beyond global rules, I maintain WARP.md files in each project directory. These contain project-specific conventions that override or augment global rules:

Portfolio Blog Project

# WARP.md
- Hyperlinks must be bold, sky blue (#38BDF8), and underlined
- Use TypeScript for all new components
- Commits must reference issue numbers
- Deploy only after visual regression tests pass

Neovim Configuration

# WARP.md
- Test all plugin changes in minimal config first
- Document keybindings in README immediately
- Use lazy loading for all new plugins
- Benchmark startup time after changes

This approach gives me:

• Consistency within projects
• Flexibility across different project types
• Documentation that lives with the code
• Onboarding help for collaborators

Advanced Techniques I've Discovered

Rule Precedence Hierarchy

After months of refinement, I've developed a precedence system:

1. Project subdirectory rules (most specific)
2. Project root rules
3. Personal workspace rules
4. Global rules (most general)

This allows incredibly nuanced behavior without complexity.

Rule Composition

Some of my most powerful workflows come from composing simple rules:

Base Rule: "Check git status after changes"
+ 
Modifier Rule: "Use --no-pager for git commands"
+ 
Context Rule: "In feature branches, suggest rebasing"
= 
Emergent Behavior: Intelligent git workflow that adapts to branch context

Dynamic Rule Generation

I've started experimenting with rules that create other rules:

Rule: "When entering a new MCP server context, search for and apply relevant context documentation rules"

This meta-rule means my system learns and adapts to new tools automatically.

Metrics: The Quantifiable Impact

After tracking my workflow for the past month:

• Commands per day: Reduced from ~500 to ~200 (60% reduction)
• Error rate: Decreased from 8% to <1%
• Task completion time: Improved by 35% on average
• Context switches: Reduced by 50% due to better organization
• Documentation coverage: Increased from 40% to 95%

More importantly, the cognitive load reduction is immeasurable. I no longer hold dozens of project-specific conventions in my head—my terminal remembers them for me.

Getting Started: Your First Five Rules

If you're inspired to start your own rule system, here are the five rules I recommend beginning with:

1. Git Commit Standards

"Always use conventional commit format with meaningful descriptions"

2. Safety First

"Never run rm -rf without explicit confirmation"

3. Project Setup

"Every new project needs a README.md and .gitignore"

4. Search Preference

"Use ripgrep for searching; fallback to grep only if needed"

5. Documentation Reminder

"After implementing a complex solution, document the approach"

Start with these, then add rules organically as you notice patterns in your workflow.

Common Pitfalls to Avoid

Through trial and error, I've learned to avoid:

1. Over-specific rules that only apply once
2. Conflicting rules without clear precedence
3. Rules that fight muscle memory (gradually transition instead)
4. Undocumented rules that you forget exist
5. Rules without clear value (if you disable it and don't miss it, delete it)

The Philosophy Behind My Rules

My rules follow three core principles:

1. Reduce Cognitive Load

Every decision you don't have to make is mental energy saved for actual problem-solving.

2. Enforce Best Practices

Rules make the right thing the easy thing. Good habits become automatic.

3. Capture Institutional Knowledge

Rules document not just what to do, but why—preserving context for your future self.

What's Next: The Future of Intelligent Terminals

I'm currently experimenting with:

• Predictive rules that anticipate needs based on patterns
• Collaborative rules shared across team members
• Adaptive rules that learn from usage patterns
• Integration rules that connect multiple tools seamlessly

The terminal is evolving from a command interface to an intelligent development partner, and rules are the language we use to teach it.

Conclusion: Your Terminal, Your Rules

After six months of building and refining my rule system, I can't imagine working without it. What started as a few convenience shortcuts has become an extension of my development thinking—a system that understands not just what I want to do, but how I prefer to do it.

The beauty of Warp rules is that they grow with you. Start small, add rules as you notice patterns, and gradually build a system that fits your workflow like a glove. Your future self will thank you every time a complex task becomes a simple command, every time an error is prevented before it happens, and every time your terminal just knows what you need.

The terminal has always been powerful. With rules, it becomes personal.

---

What rules would transform your workflow? I'd love to hear about the patterns and friction points in your development process. Share your thoughts in the comments or reach out on X.

If you found this helpful, you might also enjoy my posts on From VS Code to Warp: When Terminal Evolution Becomes Advocacy and Automating Google Tasks with google-tasks1-cli and Warp's Agentic Mode.

Tools Mentioned:

• Warp Terminal
• Conventional Commits
• ripgrep
• forgit
• lolcat
• Model Context Protocol (MCP))
• Obsidian
• Pieces for Developers

---

P.S. – Sure, Warp is proprietary. But after six months of building 50+ rules that turned my terminal into an intelligent development partner, I’ve learned the future doesn’t always arrive through the channels you expect.

If you’re curious enough to give Warp a try, here’s a small thank-you:

Use JOSHPETERSONPRO for $5 off your first month of Warp Pro (roughly 25–33% off depending on plan), and sign up through my referral link (I get credit if you do).

No pressure—just a way to save a few bucks if you want to see where the terminal is headed next.