From Scaffold to Ship: Automating Your Entire Dev Workflow

Every Python project starts the same way. You open a terminal, run mkdir, initialize a virtual environment, create a source layout, configure linters, set up testing, write CI config, add pre-commit hooks, create a Dockerfile, write a README skeleton… and 45 minutes later, you still haven't written a single line of actual code.

That ritual ends today. DevFlow is a Python project scaffolding tool that automates the entire setup — from directory structure to CI pipeline to Docker config — in a single command. It's part of the Kryptorious Tools suite, available in the $9 lifetime bundle on Gumroad.

The Problem: Setup Friction Kills Momentum

Let's be real about what the first hour of a new project actually looks like:

This isn't just time wasted. It's friction — the kind that makes you think twice before starting that side project on a Friday night. DevFlow eliminates every step above.

One Command to Start

Here's what a new FastAPI project looks like with DevFlow:

$ pip install devflow
$ devflow init payment-api --template fastapi

  DevFlow v2.4.1
  ✓ Created project structure
  ✓ Initialized git repository
  ✓ Created virtual environment (.venv/)
  ✓ Generated pyproject.toml with dependencies
  ✓ Configured ruff (linter) + mypy (type checker)
  ✓ Generated test suite skeleton (pytest + coverage)
  ✓ Added GitHub Actions CI workflow
  ✓ Configured pre-commit hooks
  ✓ Created Dockerfile (multi-stage, optimized)
  ✓ Generated README.md with setup instructions
  ✓ Created .env.template with documented variables

  Project ready at ./payment-api/
  Next: cd payment-api && source .venv/bin/activate && devflow run

The generated project structure:

payment-api/
├── src/
│   └── payment_api/
│       ├── __init__.py
│       ├── main.py              # FastAPI app with health check
│       ├── routers/
│       │   └── __init__.py
│       ├── models/
│       │   └── __init__.py
│       └── config.py            # pydantic-settings config
├── tests/
│   ├── __init__.py
│   ├── conftest.py              # pytest fixtures
│   └── test_main.py             # starter tests
├── .github/
│   └── workflows/
│       └── ci.yml               # lint → test → build pipeline
├── .env.template                # documented env vars
├── .gitignore
├── .pre-commit-config.yaml
├── pyproject.toml               # deps, ruff, mypy, pytest config
├── Dockerfile                   # multi-stage build
└── README.md                    # setup instructions, badges

DevFlow Templates: Pick Your Stack

DevFlow ships with five project templates, each optimized for its use case:

You can also create and share custom templates. DevFlow stores templates as simple directory structures with {{ variable }} placeholders — define one for your team's preferred stack and use it everywhere:

$ devflow template create --from ./my-perfect-setup --name team-standard
$ devflow init new-service --template team-standard

Beyond Scaffolding: The Full Workflow

DevFlow isn't just a project generator. It orchestrates the entire dev lifecycle by integrating with the rest of the Kryptorious toolchain:

During Development

$ devflow check    # runs ruff + mypy + bandit + envguard
  ✓ ruff: 0 errors, 0 warnings
  ✓ mypy: 0 type errors
  ✓ bandit: 0 security issues
  ✓ envguard: all required vars present

One command runs your entire quality stack. No remembering which linter you configured, no checking if mypy is in strict mode, no wondering if your .env is complete.

Before Committing

$ git add .
$ devflow pre-commit     # or let the hook run automatically
  ✓ ruff check --fix
  ✓ ruff format
  ✓ mypy src/
  ✓ envguard check
  ✓ testforge verify  # ensures test stubs aren't still TODO
  All checks passed — safe to commit.

CI Integration

DevFlow-generated projects come with a GitHub Actions workflow that mirrors your local checks. Push to any branch, and CI runs the exact same devflow check pipeline. No "works on my machine" drift between local and CI environments.

# Generated by DevFlow — .github/workflows/ci.yml
- name: Quality checks
  run: |
    pip install devflow
    devflow check --ci  # stricter mode for CI

What You Get vs. What You'd Do Manually

Pairing DevFlow with the Full Kryptorious Stack

DevFlow is the entry point, but it's designed to work with the entire Kryptorious Tools ecosystem:

• GitSweep — keep the repo you just scaffolded clean of stale branches
• EnvGuard — validate your .env and block secret commits
• TestForge — generate test stubs for the modules you create
• CSVClean + JSONGuard — when your project deals with messy data
• DataForge — slice and transform data from the command line
• Python Guardian + PR Sentinel + Release Forge + Secret Scanner — the GitHub Actions quartet that takes your project from PR to production

All 11 tools are available in a single $9 lifetime bundle on Gumroad. That's less than a single month of most SaaS developer tools — and you get lifetime updates.

Shipping Is the Goal

Automation isn't about being lazy. It's about removing the friction between having an idea and shipping it. Every minute saved on project setup, lint configuration, CI debugging, and secret scanning is a minute you can spend on the code that actually matters.

DevFlow gives you that head start. The rest of the Kryptorious stack keeps you moving. Together, they turn the 45-minute project setup ritual into a 5-second command — and keep your workflow automated from scaffold to ship.

Get the bundle →