# Why the Zipwire CLI is a Big Deal

The Zipwire CLI transforms how technical freelancers and contractors manage their workflow. Instead of context-switching between UI dashboards, it lets you do everything from the command line – just like you do with Git.

## Git for Work

You already know this workflow:

```bash
git add .
git commit -m "Fixed authentication bug"
git push origin main
```

With Zipwire, your workflow is:

```bash
zw journal track "Fixed authentication bug" -d 2h --activity "Company > Project > Bug Fix"
zw timesheet create --from 2024-01-01 --to 2024-01-31
zw timesheet send --id <timesheet_id>
```

Same mental model. Same simplicity. Different domain.

## The Real Power: Automation & Agents

Here's what makes this genuinely powerful:

### 1. **Script Your Entire Contractor Workflow**

Automate time tracking, timesheet generation, and submission via shell scripts or Python:

```bash
#!/bin/bash
# Daily automated workflow
zw journal track "$(git log --oneline -1)" -d 8h --activity "Client > Development"
# ... later in the day ...
zw journal track "Code review and testing" -d 1h --activity "Client > QA"
```

### 2. **AI Agents & Coding Tools Can Automate Everything**

This is the real game-changer. Coding agents like **Claude Code**, **Cursor**, and other AI-powered tools can:

* Analyze your git commits and automatically create journal entries
* Check your payment status and notify you when you're due to be paid
* Set up workflows and link activities
* Query your timesheet status and flag issues before submission

Here's a real example of Claude Code analyzing your git history and creating journal entries:

<figure><img src="/files/MDyUbVzoiSV9IQMiWe6H" alt="Zipwire CLI tracking development time from git logs"><figcaption><p>A coding agent analyzes your git commits and automatically creates journal entries, reducing manual data entry to zero.</p></figcaption></figure>

The agents can do much more than just track time. They can:

```bash
# Check if you've been paid for submitted timesheets
zw timesheet list --status approved

# Set up a new workflow for a client
zw workflow create --approve-name "Manager" --approve-email "mgr@company.com"

# Link your activities to billing workflows
zw workflow link --activity "Company > Development > Features" --workflow client-workflow

# Check pending timesheets before they expire
zw timesheet list --status pending
```

### 3. **Machine-Readable Output for Programmatic Access**

Unlike a web UI, the CLI outputs structured data that agents and programs can parse:

```bash
# Agents can query and analyze your data
zw journal list --format structured | jq '.entries[] | select(.duration > 480)'
zw timesheet list --format structured | jq '.timesheets[] | select(.status == "pending")'
```

This means agents can:

* Query your complete time tracking history
* Check timesheet and payment status automatically
* Validate data before submission
* Flag issues and suggest corrections

## Why This Matters for Technical Contractors

**You're already comfortable with CLIs.** You use Git, Docker, curl, and command-line tools every day. Why should you have to open a web browser to track your time?

**You understand automation.** Most of your frustration with traditional timesheet systems is that they're manual. The CLI lets you automate away the boring parts.

**You value integration.** The CLI plays well with other tools – your shell scripts, your agents, your CI/CD pipelines. It's not an island.

**You need accuracy.** By tracking time close to when you do the work (via CLI), and letting agents help automate the capture, your timesheets are more accurate than manual entry ever was.

## The Vision

Imagine this workflow:

1. **You write code and commit**
2. **A coding agent notices** (via git hooks or webhooks)
3. **The agent asks Zipwire** "What activity is this?" (via API/CLI)
4. **You press enter** (or set it up once)
5. **Time is tracked automatically**
6. **At timesheet deadline, everything is ready to send**

No manual data entry. No forgotten hours. No invoice rework.

That's not science fiction. That's what the Zipwire CLI makes possible.

***

**Ready to try it?** Start with [Getting Started](/tools-and-integrations/getting-started.md) to set up your first commands.


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.zipwire.io/tools-and-integrations/cli-introduction.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.