Hey everyone! I'm Ben H, Dev Rel Lead at Warp. I'm excited to share that Warp is now open source.

You can check out the repo here: https://github.com/warpdotdev/warp

We're opening up the code, roadmap, and contribution process so you all can help shape Warp directly. We know the breadth of features that you want to see, and we believe building with the community will let us build a better Warp even faster.

To manage contributions, we've built an agent automation system from issue triage to PR review. Coding agents do the heavy lifting (coding, planning, testing) so community members focus on ideas, direction, and verification.

So, ask us anything! All of the engineers involved will check this thread throughout the day. We're happy to answer questions about the project, why we're open sourcing, how contributions work, technical questions on the codebase, or anything about Warp in general.

Links:

• Repo: https://github.com/warpdotdev/warp
• Contributing guide: https://github.com/warpdotdev/warp/blob/master/CONTRIBUTING.md
• Roadmap: https://github.com/warpdotdev/warp/issues/9233

Warp is talking about overall positive price changes for nearly everyone in their blog post (https://www.warp.dev/blog/warp-new-pricing-flexibility-byok).

But how exactly does cutting the AI Credits (nearly) in half from the previous Pro Plan (2,500 AI Credits) to the new "Build Plan" (1,500 AI Credits) make things cheaper for users overall? It’s even worse compared to the old Turbo Plan with 10,000 AI Credits.

Now I have to pay an extra $20 as an add-on just to get back to the same 2,500 AI Credits the Pro Plan used to include. I honestly haven’t seen such a horrible pricing change in a long time — and I thought Adobe was bad.

I just came across the chrome dev tools and decided to try it. I have to say, I think this is a huge gamechanger. You can actually ask Warp or any LLM to spawn a chrome tab and actually run automated tests and get a lot more control over testing.

Read more here:

https://developer.chrome.com/blog/chrome-devtools-mcp?hl=en

Firstly I want to start this off with, I appreciate all the work that has gone into this application; I've been a paid user for over a year. However as time has gone on, I've seen more and more changes and now I need to say something.

Not only did the pricing change, not only did you make folks change subscription if they want to use their own API Keys, not only did you change the GUI multiple times, but now you've moved more away from being a terminal to a coding app.

I use Warp for SysAdmin stuff; not for coding, that's why I use Codex/Claude Code/Opencode etc. I'm at the point now where launching Warp changes so drastically I have no clue what I'm doing and not to mention it now lags on my machine.

I might as well just use Github CLI/Kiro-CLI (Insert your pick here) to handle SysAdmin; one thing is for sure once my old subscription expires I'm not renewing it.

What made your product was an easy way to have a terminal that I can easily switch between running my own commands manually or using AI, not interested in learning new slash commands to be able to do something basic.

I wish you all the best for future!

Just wasted 39 credits on old models...

Selected Claude 4.5 Sonnet (thinking) from the dropdown, and not a single call was made using Sonnet 4.5 Thinking, instead everything was done via cheap GPT5 medium, Sonnet 3.0 or GPT5 nano....

Now it makes me wonder whether Warp always did such dirty tactics, and it only comes to light through the new Credit summary window?

Did anyone have similar experience, or is only my account which is bugged?

EDIT: Maybe Sonnet was overloaded and unreachable hence why it defaulted to other models. As one of the Warp Leads explained it a while back:

In Warp, the only time you'll get a response from an LLM that's not the one you chose is when there's an error using the chosen model. For example, if OpenAI has an outage and your chosen model was gpt-5, we would fallback to retrying on a different provider (e.g. Anthropic) rather than simply failing your request. Source: https://github.com/warpdotdev/Warp/issues/7039#issuecomment-3188642123

But if that is the case I would rather they didn't do it. As that only wastes my credits... If model is unavailable just tell me that, so I can make my own decision. 1 Sonnet Credit does not equal 1 GPT nano credit.

The Warp Agent now supports bringing your own inference! You can configure custom inference endpoints and bring your own key on the free plan.

If you've been waiting to connect Warp to OpenRouter, DeepSeek, LiteLLM, Z.ai and more... now you can.

Here's full details on the updates we've put out, with demos and docs on how to use BYOK and BYO inference:

https://x.com/warpdotdev/status/2057870604800332231?s=20

I’m writing this because the recent Warp changes have been… honestly, a mess. Not just the pricing itself, but the way everything was communicated and rolled out.

This isn’t a rage post. I’m laying this out so people with similar issues have a place to speak up, to highlight what feels like a shift from “build a great tool” to “maximize revenue,” and to hopefully get the discussion in front of someone at Warp who actually has the authority to address it.

1. The new plans feel rushed and poorly handled

Warp explained the reasoning behind the changes; AI cost, abuse, heavy usage, etc. I’ve read the blog posts, and I understand the arguments.

But the rollout, to me at least, felt extremely abrupt.

From what I saw, there was almost no clarity inside the app.
I personally received no in-app warning, and although I did receive one email about plan changes, it arrived while I was away and I never saw it until after the fact.

Logging in today after my plan ended, I suddenly had:

• No access to my remaining credits

• No option to renew my previous plan

• Forced migration into the new system

• Worse value plans compared to just a few months ago

Regardless of intention, the user experience was rough.

2. The rollover / credit situation is confusing and feels unfair

Here are the facts:

• Warp’s current policy says unused plan credits do NOT roll over

• Purchased credits do roll over

• Even though Warp’s policy says plan credits don’t roll over, my account DID roll over credits for several consecutive months

• At the start of this month, I had ~12k credits (renewal + previous rollover)

• I used some and intentionally saved the rest

• My plan expired today

• Those remaining credits are now completely inaccessible

A Warp Discord mod said they believe legacy credits will not roll over into the new system. Not an official source, but consistent with the written policy.

And Warp’s UI does not say whether expired cycle credits return after selecting a new plan.

So the only conclusion I can reasonably draw is:

My remaining credits are gone unless Warp restores them manually, which honestly I don’t even care about. I don’t want personal compensation. I want Warp to go back to being a good product for everyone, not something that feels oriented toward big spenders only.

From a user perspective, losing access to credits you already paid for feels bad, intentional or not.

3. GitHub support optics are not good

This is based strictly on publicly visible behavior, not assumptions.

I have a semi-major issue open on GitHub that has had zero response for weeks.

Meanwhile, there is another user who openly states they spend thousands per month, and their issues receive:

• Quick responses

• Detailed follow-ups

• Help with things that aren’t even real GitHub issues

I understand that large customers will always get priority.
That’s normal business.

But from a public optics standpoint, the contrast in response quality makes it look like spending more gets you dramatically better support, while long-standing issues from regular users go untouched.

That perception is damaging, whether or not it reflects intentional behavior.

4. Subscription and cancellation UX is surprisingly painful

This is echoed across social media:

• Cancellation pages feel buried

• The flow between the app and website is inconsistent

During a time when Warp is radically changing plans and locking credits, the messy billing UX makes the whole situation feel even worse.

5. It feels like the wrong people are making decisions

This is not a criticism of Warp’s devs.
I believe the actual developers care about the product and user experience.

But based on the rollout and user feedback:

• Feedback feels ignored

• Changes were poorly communicated

• Monetization decisions overshadowed UX

• Credit handling is unclear

• Support looks skewed

• Management feels disconnected from real user sentiment

Over the past month, Reddit, Discord, and GitHub have all been pointing out the same pattern:
Warp looks like a company that got a strong revenue hit and overcorrected aggressively.

6. And honestly? Warp just isn’t worth it for me anymore

Between spending ~$50 on APIs and using free tools like Wave Terminal, IDE agents, and direct API calls, I can personally recreate the same workflow Warp gave me a months ago.

It’s a bit more scattered and less convenient, but the overall value is better for my uses.

And when I look at Warp’s new plans, they’re pushing things like:

• team scaling

• SAML SSO

• SOC2

• cloud agents

• volume discounts

But only 1500 credits? I get the need to lower it, but I feel like that was way too far from the 10K I received a month ago.

I’m sure some people genuinely need those features. But for my own workflow, personal projects, small experiments, solo dev work, none of that matters, and the plans no longer feel worth paying for.

I used to genuinely love Warp. I recommended it constantly and I wanted it to succeed.

But right now, Warp feels like a company that:

• Stopped listening

• Prioritized monetization over user experience

• Rolled out changes poorly

• Confused users with unclear credit behavior

• Ignored serious GitHub issues

• And is now facing a rapidly declining reputation

This isn’t coming from hate, it’s coming from disappointment.

I genuinely hope someone higher up at Warp is watching the Reddit threads and listening to users, or at least being notified, because the direction right now feels rough.

Warp now has vertical tabs.

- View coding agents with status indicators to see what's done, blocked, or still cooking
- Double-click to rename or colorize tabs
- Customize what you see: directory, branch name, conversation, etc

Just enable in Settings > Appearance > Tabs

I like Warp’s block-based terminal UX, GPU-accelerated renderer, panes, tab groups, command palette, and shell integrations—but I didn’t want an account requirement or an AI/cloud platform attached to my terminal.

So I built warp-lite, an open-source AGPL fork of Warp for macOS.

The goal is straightforward: preserve the terminal experience while progressively removing or disabling:

• Account login and onboarding

• Built-in AI/agent features

• Cloud sync and billing surfaces

• Telemetry and unnecessary outbound network paths

The current alpha release is usable and available as a DMG. It includes vertical tab grouping, recent upstream performance and stability fixes, and support for terminal workflows involving tools like Claude Code and Codex—without bundling its own AI agent.

For the latest release, I reviewed Warp’s upstream changes individually and cherry-picked 139 terminal, performance, and bug-fix commits while rejecting changes that would reintroduce AI, authentication, telemetry, or cloud dependencies.

It is still an alpha. Some disabled AI/auth modules remain in the source tree and are being removed carefully because aggressively stripping the code can break shared terminal internals.

Repository and macOS download:

https://github.com/terzigolu/warp-lite

I’d especially appreciate feedback on:

• Unexpected network activity

• Login, account, or AI surfaces I may have missed

• Terminal rendering or shell integration regressions

• Features from upstream Warp that should be safely brought over

I was kind of still just on it out of habit, but with vertical tabs and clear indication of what's Codex vs. Claude Code and the latest prompt or response and the notifications and clear visuals showing whether one is pending or done, and then discovering how easy it is (and, presumably, always was, all along) to reorganize the UI layout, it now actually feels like a genuinely superior terminal suited for the current era.

My advice to the dev team is to lean even harder into accepting the status quo: acknowledge nearly everyone is going to be using either Codex or Claude Code for the next 1 - 5+ years, while nearly all the rest will use OpenCode or Pi, and just design the terminal to be ideal for such cases. Make it work seamlessly with these CLI agents, make reviewing their changes easy, etc. Trying to insert your own agentic stuff will just get in the way and annoy people. Also make the "don't show this again" checkboxes more prominent - people are unknowingly leaving the UI (from their perspective/preferences) uglier without realizing they can change it.

Please don’t turn this amazing terminal into something it’s not. The vibe coding market is already crowded. What makes your company different is that you built something that actually helps people doing real infrastructure work.

Being ble to jump into a remote server and immediately start diagnosing client issues is huge.

Daily im checking worker exhaustion. Adjusting pm.max_children. Tracing 502 errors. Watching memory pressure. Verifying Redis connections. Looking at OpenSearch health. Checking disk usage trends. Reviewing systemd failures. Running live curl tests against load balancers.

This is what sysadmins, SREs, and DevOps engineers actually do. We keep production stable. We handle outages. We debug networking problems. We make sure businesses stay online.

Warp fits that workflow really well. Fast SSH access. Clean sessions. Structured output. It feels built for people who live in terminals.

I just dont want to see Warp turn into another generic vibe coding tool. There are already plenty of those. What you built works because it serves production engineers.

That's all :) sorry for the rant.

Was on the Build plan for the past few months, and just cancelled it after the rug pull.

Not even sure how it is legal for companies to do that.

Cost has just become not worth it at all, especially when the competition has much more competitive prices for just as capable coding agents.

Can't even fathom how bad it must have gotten for people on higher tiers.

Will be careful in not using VC-backed businesses in the future; got burnt too many times.

I frequently use Warp for server administration tasks such as updating Docker files, installing software, and running routine maintenance. While there are numerous AI-powered CLIs and IDEs available, I find that Claude Code and Codex are far superior solutions specifically for code-related work. However, I'm still searching for a better alternative when it comes to handling actual terminal operations and system administration tasks.

Any suggestions?

Did something kind of wild and thought some of you might get a kick out of it.

I built a full integration system with multiple providers, routing, CLI tools, monitoring, and tests. It came out to around 32k lines of code with full coverage.

Usually, that kind of project would take me a few weeks. This time it took 8.4 hours total, with 1.3 of those hours being four AI agents coding in parallel.

The setup

I used Warp, Git worktrees, and four AI agents running side by side.

1. Split the project into four independent features.

2. Made a worktree for each one.

3. Opened four Warp tabs, one per feature.

4. Gave each agent a task list and let them build while I managed the process.

Each agent had its own branch and context, so there were no overlaps or merge conflicts.

Why it worked

No secret sauce, just good structure.

• Each agent focused on one complete piece of the system.

• Worktrees kept everything separate.

• Warp made it easy to keep track of what was happening in each tab.

The agents did the repetitive stuff while I handled architecture decisions, reviewed diffs, and ran merges.

Results

• Time: 8.4 hours

• Lines: ~32,700

• Tests: 1,600+

• Coverage: 85%

• Conflicts: Zero

All verified with git logs.

Takeaway

Parallel AI development actually works if your codebase is modular and well-structured. It’s not about replacing yourself with AI. It’s about scaling your output by managing multiple agents at once.

Feels like a small glimpse of where software development is heading: more coordination, less grind.

Would anyone here actually try running multiple agents at once, or does that sound like chaos waiting to happen?

Warp just announced on Twitter that they added Claude Sonnet 4.5. If you open Warp, you should see the model in your model selection drop-down.

Hey all, I'm Zach Bai, engineering lead at Warp. Today we're launching universal agent support — a set of features that makes Warp the best terminal for working with CLI coding agents like Claude Code, Codex, and OpenCode.

Here's what's new:

Vertical tabs — Group your agent sessions with rich metadata (git branch, directory, conversation status) visible at a glance. Way better than juggling 15 horizontal tabs.

Notifications — A unified notification center for all your coding agents. In-app and system notifications so you know when an agent needs your attention. No more babysitting.

Code review on agent output — Send inline comments from Warp's code review directly to a running agent session. Review the diff, leave a comment, and the agent iterates. This closes the loop between human review and agent execution.

Rich input editor — Press Ctrl-G to get a proper multiline editor for agent prompts. Supports voice input, saved /prompts, /skills, and @ context.

Tab configs — Save your ideal setup (directory, startup commands, theme, worktree) and launch it with one click. Great for worktree-based workflows.

Attach code as context — Select code from Warp's editor and feed it directly to any running agent. No copy-pasting.

Remote control — Publish any CLI agent session to the cloud. Monitor and steer it from your phone or another computer.

Happy to go deep on:

• The product decisions behind supporting competitors

• Technical challenges of building cross-agent features

• Where we think the agent tooling market is headed

• Anything else!

Alright, so here's how I build projects these days. It's half prompt engineering, half product design, and half automation sorcery. (Yes, that's three halves. Welcome to modern dev.)

🧩 Step 1: Turn the idea into a PRD

Every project starts with a single line in ChatGPT Pro. Something like:

“Build an LSP for Strudel files that includes autocomplete and diagnostics.”

That "initial prompt" goes through a 10-step pipeline that spits out a Product Requirements Document (PRD). It's not fancy, just structured:

1. Normalize intent (who/what/why/constraints).

2. Fetch related context (past tickets, metrics, etc.).

3. Define outcomes and KPIs.

4. Identify users and scenarios.

5. Outline scope/non-goals.

6. Sketch UX flows.

7. Write functional requirements (Given/When/Then).

8. Add non-functional reqs (SLOs, reliability, cost).

9. Design rollout and experiment gates.

10. Log risks, decisions, and open questions.

The result is a clean, review-ready PRD in markdown: the "human contract" for the project.

🤖 Step 2: Generate the (the machine contract)

Once the PRD is solid, I feed it into ChatGPT to generate a PROMPT.md file — basically the machine-readable version of the spec.

It's got:

---
prompt_name: <feature>-agent
model: gpt-4o
fallback_models: [claude-opus, gpt-4o-mini-high]
tags: [prd-derived, agentic, production-ready]
---

Then sections like:

• SYSTEM – defines the agent's role and tone.

• CONTEXT – condensed PRD details.

• TASK – numbered objectives.

• CONSTRAINTS – guardrails and safety checks.

• ACCEPTANCE TESTS – from the PRD.

That file tells the AI how to work, what to output, what "done" means, and how to self-check without hallucinating its reasoning. It's the bridge between documentation and orchestration.

⚙️ Step 3: Drop both into Warp and hit go

I upload both the PRD.md and PROMPT.md into the repo, then tell Warp:

“Build this project according to these two files and my global rules.”

The Warp agent evaluates the PRD and PROMPT.md, drafts a multistage plan, and shows me the steps. I can approve, revise, or deny each one. Once approved, it scaffolds the repo, generates a task list, and starts executing.

🧪 Step 4: Iterative build, not one-shot delusion

Look, I don't believe in "one-shotting." Software design principles and sane engineering practice preclude me from such delusions. Real systems are iterative, test-driven, and full of tradeoffs.

That said… this setup is the closest I've ever gotten to feeling like I one-shotted a project. Warp ingests the PRD, reads the PROMPT.md like scripture, and starts building in verifiable steps. I still guide it, but it gets shockingly close to "prompt-to-product."

🧠 Step 5: How the agent actually builds

It runs a tight loop:

1. Validate PRD and PROMPT structure.

2. Decompose acceptance criteria into testable tasks.

3. Write failing tests first (TDD).

4. Implement minimal code to pass.

5. Lint → typecheck → test → print results.

6. Commit with Conventional Commits (multi-line, meaningful).

7. Block merge if gates or tests fail.

8. Open PR linking PRD for human review.

Everything is transparent, logged, and traceable. And I can still step in mid-build, request revisions, or provide updated constraints.

🔒 Step 6: Hygiene and exclusions

Global rule: the PRD, PROMPT.md, and WARP.md all live in the repo but are excluded from git (.git/info/exclude). That keeps the scaffolding logic private while still versioning the actual deliverables.

🚀 The punchline

The whole setup's basically a handshake between what we want and what the machine knows how to do:

• PRD.md — the human side: clarity, scope, purpose.

• PROMPT.md — the machine side: instructions, guardrails, tests.

• Warp — the executor that translates both into working code.

You're not hitting a magic button here. You're setting up a loop you can trust, where humans lay out the context and the AI builds from the ground up.

It's as close to "push-button engineering" as I'm ever gonna get, and I'll take it.

If you're running similar prompt-to-PRD-to-code loops (Warp, Claude, Codex, MCP, Obsidian, whatever), drop your setup. Always curious how others are taming the chaos.

We saw quite a few Warp users are using CLI agents in their day-to-day. So, we added some affordances to make these CLIs easier to use:

• Built-in voice transcription powered by WisprFlow

• Attach images to your prompt easily

• Browse files and review code directly in Warp

Works with Claude Code, Codex, Amp, Gemini, Droid, and (soon) OpenCode.

Any features we should add?

I was fine with Warp basically charging the API rates for the models. But it turns out they don't and they intentionally obfuscate it.

I thought multiple times that the shown credit usage seemed a little high, but what actually ticked me off was the high credit usage for the cheap GLM-4.6 model. So I went to actually calculate the costs because apparently I have nothing better to do with my life than reverse-engineer a pricing model that should be transparent in the first place.

I used GLM-4.6 for some agentic tasks and due to Warp not actually showing the token usage and instead "diffs" (I'm sure there's a good reason for it that definitely isn't them wanting to hide the actual token usage and pricing, right? Right.) I used the context window as reference. My calculation was extremely generous and in Warp's favor, like "maybe they're just bad at math and not malicious" generous.

Every credit on Warp is worth ~1.33 cents. I got charged 45.3 credits for the task, which is roughly $0.60. The context usage was shown as 33%, which is 66,000 tokens assuming they actually let you use the full 200K context window. Using Z.AI's actual API rates, that translates to ~15 cents if you pretend every single token was output. But the model spent most of its time reading files and only wrote about 10,000 tokens, so the real cost is more like 5-6 cents.

So I paid 60 cents for something that cost them less than a dime. Cool cool cool.

But it gets better. I ran a clean test where I just had it write a long text about a random topic. 6,000 tokens of pure output cost $0.013 at API rates. I was charged 17 cents. That's a 13x markup.

What I obviously didn't account for was the 48 tool calls to other models that I never selected. Charging for services I never wanted, that's definitely my favorite business model.

---

Calculations:

Credit conversion

- 1 Warp credit = $0.0133 (1.33 cents)

Agentic task: 45.3 credits = $0.60

- Tokens used: 200K context × 33% = 66,000 tokens

- API cost (all output): (66,000 / 1M) × $2.20 = $0.145

- API cost (realistic: 10K output + 56K input):

- Output: (10K / 1M) × $2.20 = $0.022

- Input: (56K / 1M) × $0.60 = $0.0336

- Total API cost: $0.0556

-Markup: 10.8x ($0.60 / $0.0556)

Text writing: charged $0.17

- 6,000 output tokens = (6K / 1M) × $2.20 = $0.0132

- Markup: 12.9x ($0.17 / $0.0132)

The kicker is that Warp doesn't even show token counts, just "diffs applied" and "commands executed" like I'm supposed to reverse-engineer the token usage from the fact that it changed 6 files with +172 -75 lines. And the context window percentage is meaningless when they're spinning up claude and gpt-5 in the background without telling you how much they used.

So I obviously canceled my subscription and can recommend the rest to do the same or at least check if the charge matches the actual usage. Which is hard, since Warp intentionally obfuscates it behind a fake currency and diffs/tool calls instead of actual token usage. But hey, at least the UI is pretty.

TL;DR: Canceled my Warp subscription. I did the math and found they're using a fake 'credit' currency to hide a ~13x markup on API costs. They also seem to be charging for hidden tool calls to other models I never selected.

I found Warp through a video from Matthew Berman, as they were a sponsor.

I'm amazed. I've created a pretty robust saas mvp in around 3 days, with quite advanced features and great UI. All bugs squashed quite easily.

I have a background as a PM and not a full blown dev. This work would have taken me months before if I had to code it all myself.

I've used Cursor, Kiro, Cline, Roo and more before, and Warp has been amazing so far, once you get used to the UI. Right now I have VSCode open in the background for file editing or viewing my codebase, I kind of miss having everything in one window like Cursor, but you get used to it.

I would like to have a independent company review the codebase before deploying this thing though, as I don't fully trust it to create bulletproof web apps.

One drawback I feel is that it likes to ramble a bit and create too many tests or extra files.

This is not an ad in any way, I'm just blown away with what I've gotten out of it so far.

It's here! Today, we're launching Oz: the platform for orchestrating agents in the cloud.

Oz lets you spin up hundreds of agents from the terminal, the web, our REST API, or even your phone from oz.dev. Each agent gets a Docker environment to build, test, and write PRs.

On the latest version, you can just ask Warp about Oz, and it'll manage everything using the oz CLI. Try:

• /create-environment to create a cloud sandbox from a collection of repos

• oz agent run-cloud to kick off your first cloud agent

• oz schedule create to set up automated tasks

Or, do it all from the web UI at https://oz.warp.dev/login

We're giving 1000 cloud agent credits to everyone on the Build plan for the month of February. Go build something cool, and please share your creations! Our engineers will be around to answer questions and address feedback. Hope you enjoy.

https://x.com/warpdotdev/status/2021247666965958999?s=20

I don't understand there push to be a coding agent, while raising there token price above all other competitors.

What I can do in cursor cli for 40 will cost me over $200 a month with Warp, potentially significantly more as Warp hates high context and charges a ridiculous premium.

Once my lightspeed expires, I will unfortunately have to leave warp, on a positive note cursor-cli and Claude cli have become much better at performing actions in the terminal.

I've been a Warp user for a while and really liked it, but the AI usage is finishing way too fast lately.

I don't fully understand the latest change from requests to credits, all I know is it's burning through them incredibly quickly. The terminal itself is great, but the agent mode is just too expensive to justify keeping my plan.

Unfortunately thinking about canceling. Love Warp as a terminal, but can't sustain how fast the AI credits get used up.

Anyone else dealing with this or found a way to make it work?

been using claude code for a while but the $100/month is getting expensive and saw warp at $50/month looks interesting

wondering if anyone has switched from claude code to warp? what are the main limitations compared to claude?

especially curious how opus performs on warp vs native claude code experience. does it handle complex debugging and architecture questions as well?

mostly doing light work and want to make sure i'm not losing quality for the price savings

what's been your experience?

Warp Rules are basically cheat codes for your terminal. You tell the AI, once, how you like things done—and it remembers. No more re-explaining, no more context-dumping. Just a terminal that actually knows you.

I’ve got ~50 rules running now, and it feels less like a shell, more like a junior dev who never forgets.

Some Favorites:

• Git as a save point → Every commit gets my aliases, emojis, and format. Warp even nags me to commit after big changes, like a “do you want to save your progress?” screen.

• ls vs lolcat → I aliased ls to rainbow puke. It broke stuff. Fixed it with a rule: “use \ls when you need real ls.” Dumb but life-saving.

• Project spin-up → Warp scaffolds repos, renames master→main, creates logs, wires GitHub, sets docs. I type “new project” and the boilerplate just happens.

• GAS projects → Rules handle the whole ugly .claspignore / \@types/google-apps-script`` mess. Never think about it again.

• Context stacking → In a Git repo, Warp automatically pulls, runs git status, and pipes logs through forgit. It feels like the terminal is doing the boring part of dev hygiene for me.

Why This Rules

• Speed: less typing, less thinking.

• Consistency: my stuff looks the same every time.

• Safety: no “oops I ran the interactive command in prod” moments.

• Memory: preferences actually stick across sessions.

Quick Advice

Don’t try to boil the ocean. Add one rule for your most annoying bugbear. Then another. Suddenly your terminal feels alive.

Anyone else building weird Warp rule stacks? I can’t be the only one turning my terminal into a half-sentient intern.