PWV Portfolio Feed

Firecrawl is joining Leap Week.

On March 25, we're showing how to pull structured data from anywhere on the web and push it directly into your backend. 

Firecrawl handles the extraction. Directus handles the rest.

1 HOUR from now!! :)

if you're doing code review, try /review and /pr-comments. pay attention to how much mental energy you save by not switching contexts. that's the real value.

here's a quick video demo
$ npm i -g command-code

command code gets this. it's built around the terminal because that's where developers actually work. not as a gimmick GUI, but as a fundamental design principle.

tools should minimize context switching. every context switch is a tax on your productivity and your ability to think deeply. the best tools keep you in flow. we built Command Code to provide you with the best agentic developer experience.

this is the kind of feature that seems small until you use it. then you realize how much friction it removes from your daily workflow.

- learning (see patterns in how your code is reviewed)
- taste aware (Command continuously learns your coding/reviewing taste, and compounds in value after every session)

by keeping you in the terminal, command code preserves your cognitive state. you stay in the problem. you stay in flow.

this is especially valuable for:
- async review workflows
(get feedback immediately without waiting for humans)
- rapid iteration (fix feedback in the same session)

4. commit and push without ever leaving the terminal

why does this matter?

context switching is a form of cognitive load. code reviews are the biggest bottle neck today. every switch degrades your working memory. you lose the mental model you've built. you lose momentum. you lose flow.

this is subtle but powerful. you're not just seeing the comments, you're immediately positioned to act on them. the friction is gone.

the workflow becomes:
1. /review → get structured feedback/score
2. /pr-comments → see all comments
3. continue in the same session to fix issues

/pr-comments does something equally important: it fetches all comments (both issue comments and inline review comments) and displays them in your terminal. then it pre-populates the next action to help you: "fix all review comments".

- potential edge cases you might have missed
- whether test coverage is adequate
- security implications of the changes

- returns a structured review with a quality score (1-5)
- respects your project's learned conventions (your taste of code/review)

it's semantic agentic analysis. it understands:
- whether your abstractions make sense
- if you're following project patterns

/review gives you structured code analysis without leaving the terminal. it:
- auto-detects your PR from your current branch (no manual lookup)
- fetches the diff and metadata via gh CLI
- analyzes the changes for quality, correctness, style, performance, security

each switch costs you. research shows context switching can cost 15-25 minutes of productive time per switch. if you do 3-4 reviews a day, that's an hour+ of pure overhead.

command code's /review and /pr-comments commands eliminate this entirely.

1. leave your terminal
2. navigate to github
3. parse the diff (often poorly formatted)
4. read comments from several agents/humans
5. come back to your terminal
6. context-switch back into the problem

# auto-detects PR from branch

$ cmd
/review 42
# explicit PR number

$ cmd
/pr-comments
# Fetch all PR comments for current branch

the problem with code review is that it's fundamentally a context-switching tax.

you're deep in the flow of your work, and suddenly you need to:

Introducing Taste Aware Agentic Review /𝚛𝚎𝚟𝚒𝚎𝚠
by Command Code

Stop paying the code review tax. 

Code review in your terminal. Slash commands that turn GitHub PRs into structured feedback. No browser, no context switching, no friction.

$ cmd
/review

$ cmd
/review

Coding agents are reshaping how we build software. Here is a simple way to use them well:

1. Start with a clear goal
2. Give context and constraints
3. Review outputs and refine

The secret is taste. Guide the agent with good judgment and it will amplify your skills.