Autohand Code in Your SDLC

Planning and design

Before writing any code, use Autohand Code to explore what already exists and figure out what needs to change. Plan Mode lets you ask questions and analyze your codebase without making any modifications.

Explore your codebase

Ask Autohand Code to map out how things work before you start building:

autohand --plan "How is authentication implemented in this project?"

Autohand Code reads your files, traces the flow, and gives you a clear picture of the current architecture. This is useful when you are joining a new project or working in an area you have not touched before.

Generate technical specifications

Turn high-level requirements into detailed technical specs:

autohand --plan "What would need to change to add multi-tenancy support?"

Autohand Code identifies the files, database changes, and API updates needed. You get a concrete plan before writing a single line of code.

Implementation

Once you have a plan, Autohand Code helps you build. Describe what you want in plain English, reference existing patterns, and let Autohand Code handle the multi-file edits.

Feature development with context

Reference existing code to keep new features consistent:

autohand --automode --max-iterations 10 "Build the user settings page following the same patterns as the profile page"

Autohand Code reads the profile page, picks up on your component structure, styling conventions, and data fetching patterns, then applies them to the new settings page.

Multi-file changes

Autohand Code edits across your entire codebase in a single pass. Add a new API endpoint and it updates the route, controller, validation, types, and tests together.

Auto Mode for autonomous execution

Auto Mode lets Autohand Code run multiple steps without pausing for approval at each one. Set a max iteration limit to keep it bounded. Autohand Code still respects file permissions and will not touch files outside your project.

Agent Teams for large tasks

For bigger projects, spin up Agent Teams to parallelize the work. One agent handles the backend while another builds the frontend. They coordinate through a shared task list and stay in sync automatically.

Code review

Before you commit, let Autohand Code review your changes. It catches bugs, spots missing edge cases, and flags things you might have overlooked.

Review your own changes

git diff --staged | autohand "Review these changes and flag any issues"

Autohand Code reads the diff, checks for common mistakes, and suggests improvements. It knows the context of your project, so the feedback is specific to your codebase rather than generic advice.

Review pull requests from teammates

Pipe a PR diff into Autohand Code to get a second opinion before approving:

gh pr diff 42 | autohand "Review this PR for correctness and security issues"

Testing

Autohand Code writes tests that match your existing test patterns. It detects your framework, follows your naming conventions, and covers the paths that matter.

Generate unit tests

autohand "Write tests for the checkout flow covering empty cart, expired coupons, and payment failures"

Autohand Code reads your checkout code, identifies the important branches, and generates tests for each scenario. It uses the same test framework and assertion style as the rest of your project.

Write integration tests

For API endpoints, Autohand Code generates tests that hit your routes, check status codes, validate response shapes, and test error handling.

Find untested edge cases

Ask Autohand Code to look at existing tests and find gaps. It identifies code paths that are not covered and writes the missing tests.

Documentation

Autohand Code reads your code and generates documentation that stays accurate because it comes directly from the source.

Generate README files

Point Autohand Code at your project and get a README that covers setup, usage, and configuration:

autohand "Generate a README for this project based on the codebase"

Write API documentation

Autohand Code reads your endpoint definitions and generates docs with request/response examples, parameter descriptions, and error codes.

Keep docs in sync

After making changes, tell Autohand Code to update the relevant docs:

autohand "Update the README to reflect the new CLI flags added in the last 3 commits"

Git workflow

Autohand Code integrates with Git to make your version control workflow faster and more consistent.

Commit with meaningful messages

Run the built-in commit command and Autohand Code analyzes your staged changes, writes a clear commit message, and creates the commit:

autohand /commit

Review diffs before merging

Before merging a branch, pipe the diff to Autohand Code for a final check. It flags anything that looks off and highlights potential conflicts.

Resolve merge conflicts

When Git cannot auto-merge, Autohand Code reads both sides of the conflict, understands the intent behind each change, and resolves it correctly.

CI/CD and automation

Autohand Code runs in headless and pipe modes for integration with your CI/CD pipelines. No interactive terminal required.

Pipe Mode in CI pipelines

Use Pipe Mode to feed input and get structured output:

autohand -p "Check for security vulnerabilities" --json

GitHub Actions example

# GitHub Actions example
- name: Code review
  run: |
    git diff origin/main...HEAD | autohand -p "Review for security issues" --json > review.json

This works with GitHub Actions, GitLab CI, Jenkins, or any CI system that can run shell commands. Autohand Code outputs structured JSON that downstream steps can parse and act on.

Headless mode for background automation

Run Autohand Code in the background without a terminal attached. Useful for scheduled tasks, webhook handlers, and automated pipelines.

For a complete setup walkthrough, see the CI/CD Automation guide.

Debugging in production

When something breaks in production, Autohand Code helps you find the root cause fast.

Analyze error logs

Pipe your logs directly into Autohand Code:

cat error.log | autohand "Find the root cause of these errors"

Autohand Code reads the log entries, correlates timestamps, identifies patterns, and points you to the code that is causing the problem.

Trace issues across services

In microservice architectures, Autohand Code can follow a request across multiple services by reading logs and code from each one. It maps out the full call chain and pinpoints where things went wrong.

Generate hotfixes safely

Use Plan Mode first to see what Autohand Code would change, then approve and apply the fix. This gives you a dry-run before touching production code.

The full workflow

Here is a typical development cycle using Autohand Code at every stage:

1. Plan: autohand --plan "What needs to change for feature X?"
2. Build: autohand "Implement feature X following the plan"
3. Test: autohand "Write tests for the changes I just made"
4. Review: git diff | autohand "Review my changes"
5. Commit: autohand /commit
6. Document: autohand "Update docs to reflect the new feature"

Each step builds on the previous one. Autohand Code keeps context between commands in the same session, so it knows what you planned, what you built, and what needs testing.

Next steps

• CI/CD Automation - Set up Autohand Code in your continuous integration pipeline
• Pipe Mode - Learn how to use Autohand Code with stdin and stdout
• Headless Mode - Run Autohand Code without a terminal
• When to Use Autohand Code - Understand which tasks Autohand Code handles best