Professional Agentic Workflows

The Professional Context

Professional agentic development differs from casual vibecoding in key ways:

Core Principles

1. Agent as Junior Developer

Treat AI like a skilled but inexperienced team member:

• Provide clear context and constraints
• Review all output before committing
• Don't trust it with sensitive operations
• Pair complex tasks with your expertise

2. Minimal Blast Radius

Structure work to minimize impact of errors:

• Feature branches for all AI work
• Small, focused commits
• Rollback capability at every step

3. Verification at Every Step

Never assume AI output is correct:

• Compile/lint after every change
• Run relevant tests
• Check diff before committing

Setting Up Your Workflow

Repository Structure

Add these files to every repository:

your-repo/
├── AGENTS.md          # Instructions for AI tools
├── .cursorrules       # Cursor-specific rules (if using Cursor)
├── .claude/           # Claude Code settings
│   └── settings.json
└── .github/
    └── prompts/       # Reusable prompt templates

AGENTS.md Template

# AI Agent Guidelines

## Project Overview
[Brief description of the project]

## Tech Stack
- Language: [e.g., TypeScript]
- Framework: [e.g., Next.js 15]
- Testing: [e.g., Jest + Playwright]

## Code Conventions
- [List key conventions]
- [Naming patterns]
- [File structure rules]

## Off-Limits
- Do not modify: [sensitive files]
- Do not run: [dangerous commands]
- Do not commit: [secret patterns]

## Testing Requirements
- Run `npm test` before suggesting changes
- All new code needs tests

## Commit Message Format
[Your format, e.g., Conventional Commits]

The Professional Workflow

Phase 1: Branch Setup

bash
Copy
# Create a feature branch with descriptive name
git checkout -b feature/add-user-authentication

# Verify clean state
git status

Phase 2: Context Gathering

Before asking AI for help, gather:

1. Relevant existing code
2. Test files that cover the area
3. Documentation/specs

Phase 3: Constrained Requests

I need to implement {{feature}} in this codebase.

## Constraints
- Follow existing patterns in [file]
- Must work with [existing system]
- Cannot modify [off-limits areas]

## Testing Requirements
- Unit tests required
- Must pass existing test suite

## Deliverables
1. Implementation code
2. Tests
3. Brief documentation

Please start by explaining your approach before writing code.

Phase 4: Incremental Implementation

Work in small steps:

1. Plan - Get AI to explain approach
2. Implement - One function/component at a time
3. Test - Run tests after each step
4. Commit - Small, reviewable commits

Phase 5: Review and Iterate

Before creating a PR:

• All tests pass
• Lint passes
• Diff is reviewable (< 400 lines ideal)
• No sensitive data exposed
• Documentation updated

Integrating with CI/CD

Ensure your CI catches AI-generated issues:

yaml
Copy
# .github/workflows/ci.yml
name: CI
on: [push, pull_request]

jobs:
  check:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
      - run: npm ci
      - run: npm run lint
      - run: npm run typecheck
      - run: npm test

Learning from Production Codebases

The best way to understand production patterns is to study real systems. If you're building a SaaS product, here's what a production backend typically looks like:

• Auth service: Registration, login, OAuth, sessions, API keys
• Billing service: Stripe integration, subscriptions, usage tracking
• Notification service: Email/SMS templates, queues, delivery tracking
• Multi-tenant architecture: Data isolation, organization management

StackForDevs is an example of this architecture. You can use it as:

1. A reference — study how production services are structured
2. A foundation — build your product on top of its APIs
3. A comparison — see how your own implementation compares

The AGENTS.md example in our System Documents lesson is from this codebase. Whether you build your own backend or use a platform, understanding these patterns helps you make informed decisions.

Verify

You've set up a professional workflow if:

• Your repo has AGENTS.md with clear guidelines
• You work on feature branches
• CI runs on every push
• You can explain why each step matters

Next: Learn how to containerize your development environment for consistent AI-assisted development.