Codify – Terraform for Developer Environments

TL;DR

TL;DR: Codify is an open-source CLI that brings Infrastructure-as-Code discipline to local development environments—declare your toolstack in a JSONC file, run codify plan to preview changes, and codify apply to roll them out consistently across machines.

Source and Accuracy Notes

⚠️ This section is MANDATORY. All links must be verified from actual source, not guessed.

• Project page: codifycli.com ← MUST visit and verify
• Source repository: github.com/codifycli/codify ← MUST read README
• License: Apache-2.0 — verified via GitHub API
• HN launch thread: news.ycombinator.com/item?id=49009414

What Is Codify?

Every developer knows the pain: a new laptop means hours of reinstalling Homebrew packages, configuring Git and SSH keys, setting up VS Code extensions, cloning repos, and tweaking macOS preferences. Codify brings the same workflow you use for cloud infrastructure to your local machine.

From the project README:

Stop manually setting up your development environment. Define it once, replicate it everywhere.

The core idea is a codify.jsonc configuration file that declares what your environment should look like:

[
  {
    "type": "homebrew",
    "formulae": ["git", "node"]
  },
  {
    "type": "vscode"
  },
  {
    "type": "docker"
  }
]

Codify then handles installing, configuring, and keeping those components in sync. It is built on oclif, the CLI framework used by Heroku and Salesforce, and ships as a single binary for macOS and Linux.

Setup Workflow

Step 1: Install Codify

# macOS via Homebrew
brew install codifycli/tap/codify

# Or download the binary directly from GitHub releases
curl -L https://github.com/codifycli/codify/releases/latest/download/codify-macos-arm64 \
  -o /usr/local/bin/codify
chmod +x /usr/local/bin/codify

Step 2: Initialize from Your Current Machine

If you already have a configured dev environment, codify init detects installed tools and generates a codify.jsonc for you:

codify init

It scans for Homebrew packages, VS Code, Docker, asdf plugins, AWS CLI, and more—then presents an interactive selector to choose which ones to import.

Step 3: Write or Edit Your Configuration

A minimal configuration that sets up Git, Node via nvm, VS Code, and Docker looks like this:

[
  {
    "type": "homebrew",
    "formulae": ["git", "curl", "wget"]
  },
  {
    "type": "nvm",
    "nodeVersions": ["20"],
    "global": "20"
  },
  {
    "type": "vscode",
    "extensions": ["dbaeumer.vscode-eslint", "esbenp.prettier-vscode"]
  },
  {
    "type": "docker"
  }
]

Step 4: Plan Before You Apply

The codify plan command shows exactly what will change before touching your system:

codify plan

╭───────────────────────────────────────╮
│Codify Plan                            │
╰───────────────────────────────────────╯
The following actions will be performed:

 + nvm will be created
  {
      "nodeVersions": ["20"],
      "global": "20"
  }

 + vscode will be created
  {
      "directory": "/Applications"
  }

Step 5: Apply Changes

When the plan looks right, apply it:

codify apply

Deeper Analysis

What makes it different from alternatives?

| Tool | Approach | Learning Curve | |---|---|---| | Codify | Declarative JSONC config, plan + apply | Low | | Nix / NixOS | Functional package manager, custom language | High | | Ansible | Imperative YAML playbooks, SSH-based | Medium | | Chef / Puppet | Pull-based config management | High | | Homebrew Bundle | Homebrew-only, no plan step | Low |

Codify sits at the intersection of simplicity and power. Unlike Nix (which requires learning a functional language for non-trivial configs), Codify uses JSONC—a superset of JSON with comments—making it immediately readable.

The plan before apply checkpoint is the Terraform DNA showing. It means you never blindly run an install script against a machine you do not know.

What it manages out of the box:

From the README, the plugin library covers:

• Homebrew — formulae and casks
• VS Code — extensions and settings
• Docker — Docker Desktop and containers
• Git — configuration and SSH keys
• nvm / node — Node version management
• macOS settings — system preferences
• AWS CLI — toolchain configuration
• GitHub CLI
• asdf — multi-language version manager

The plugin system is open, so you can build your own plugin for any tool not yet supported.

License and source:

Codify is fully open source under Apache-2.0. The repository at github.com/codifycli/codify is active (last push July 2026). The project also ships a web editor at dashboard.codifycli.com alongside the CLI.

Practical Evaluation Checklist

• [ ] codify --version runs without errors
• [ ] codify init detects installed tools on the current machine
• [ ] codify plan shows a readable diff of pending changes
• [ ] codify apply installs a missing package (e.g., a new Homebrew formula)
• [ ] Configuration file (codify.jsonc) is version-controlled in a repo
• [ ] Plugin documentation covers a tool you actually use

Security Notes

• Codify makes system-level changes (Homebrew installs, macOS preference writes). Review codify plan output carefully before approving.
• The configuration file runs arbitrary tool installations—treat it like a package.json or Gemfile: only install from trusted sources.
• No telemetry or network calls to third-party servers beyond the package managers themselves. The binary is self-contained.
• Homebrew’s own audit steps (brew audit) run as part of the homebrew plugin where applicable.

FAQ

Q: Does Codify replace Homebrew, asdf, or Docker Compose? A: No. It wraps and coordinates them. Codify delegates actual installation to the underlying package managers while providing the declarative layer and plan/apply workflow on top.

Q: Can I use Codify on a team? A: Yes. Commit your codify.jsonc to a shared dotfiles repo and every team member gets the same environment with one codify apply. The README specifically calls out team onboarding as a primary use case.

Q: Does it work on Linux? A: Yes. Codify supports both macOS and Linux. The plugin set differs slightly (e.g., no Homebrew on Linux; apt/apt-get instead), but the core workflow is identical.

Q: How is this different from just using a shell script? A: Shell scripts are imperative—you script the steps, not the desired state. Codify is declarative: you describe what the environment should look like, and Codify figures out the delta. This makes codify plan meaningful and idempotent runs safe.

Q: Is there a web or GUI editor? A: Yes. The project ships a dashboard at dashboard.codifycli.com alongside the CLI, plus a JSONC-based editor for writing configurations without hand-editing.

Conclusion

Codify solves a real and recurring problem: developer environment drift. By applying the proven Terraform mental model—write declarative config, plan, apply—to local machine setup, it makes “my machine works differently than yours” a solved problem.

If you spend time onboarding developers, maintaining multiple machines, or just want a reproducible dev environment you can version-control and share, Codify is worth the 10-minute setup investment.

brew install codifycli/tap/codify
codify init

Then commit the resulting codify.jsonc to your dotfiles and your entire team gets the same setup in one command.