Slava Dubrov Edge of Context
Buscar

Configuração de um MacBook para AI Engineering: ferramentas e fluxo de trabalho no macOS

Viacheslav Dubrov

· Atualizado · 7 min · Ferramentas de desenvolvimento

Tradução automática Este artigo foi traduzido automaticamente a partir da versão original em inglês.

Esta é a configuração que aplico a um MacBook acabado de instalar antes de começar trabalho de AI engineering. Abrange as ferramentas de linha de comandos que o macOS não inclui, o Homebrew, Python com uv, a shell, as escolhas de terminal e editor, Docker e ferramentas de AI locais.

A distinção útil é entre fundamentos necessários e preferências pessoais. Xcode Command Line Tools, Homebrew, Git e um fluxo de trabalho de Python são fundamentos. Warp, iTerm2, Powerlevel10k, Cursor e executores de modelos locais são escolhas. Os comandos abaixo instalam os fundamentos; as secções seguintes registam as escolhas que faço sobre essa base. Esta é uma sequência de configuração documentada, não uma imagem de máquina reproduzível bit a bit.

Instalar os fundamentos do macOS

Comece pelas ferramentas de linha de comandos da Apple:

xcode-select --install

O macOS abre uma caixa de diálogo que orienta o utilizador durante a instalação.

O Homebrew é o package manager que uso para o resto desta configuração:

Descarregue o instalador numa revisão analisada, verifique o respetivo digest, inspecione-o e execute a cópia local:

(
    set -e
    homebrew_installer="$(mktemp)"
    trap 'rm -f "$homebrew_installer"' EXIT
    curl --proto '=https' --tlsv1.2 --fail --location --show-error https://raw.githubusercontent.com/Homebrew/install/150c69df1e54b0b74c9fcca5a201410a2300816a/install.sh -o "$homebrew_installer"
    printf '%s  %s\n' 12479a24be3f5307eecac7cde670fad7118640f031229e964f544b1367b52a41 "$homebrew_installer" | shasum -a 256 --check
    less "$homebrew_installer"
    /bin/bash "$homebrew_installer"
)

O guia de instalação do Homebrew explica as alterações e os prefixos predefinidos. Em Apple Silicon, o Homebrew usa /opt/homebrew. Execute o comando brew shellenv apresentado no final para que brew fique disponível na shell atual. O instalador pode também configurar o prefixo do Homebrew para futuras login shells. O commit pin e o SHA-256 protegem o ficheiro de bootstrap; atualize-os em conjunto depois da revisão. O próprio Homebrew é um package manager rolling, pelo que os comandos brew install posteriores continuam a resolver as versões atuais das formulas no momento da execução.

Instale as ferramentas de linha de comandos que uso regularmente:

brew install openssl readline sqlite3 xz zlib uv htop gitmoji pandoc ncdu tmux

Os pacotes dividem-se em três grupos:

  • openssl, readline, sqlite3, xz e zlib fornecem bibliotecas para cargas de trabalho comuns de Python e de linha de comandos.
  • uv gere versões de Python, ambientes, dependências, comandos e lockfiles.
  • htop, tmux, ncdu, gitmoji e pandoc abrangem monitorização de processos, sessões de terminal, inspeção do disco, formatação de commits e conversão de documentos.

Usar uv no trabalho diário com Python

Antes de adotar uv, usava pyenv para gerir ambientes de Python. Atualmente, uv cobre o meu fluxo de trabalho diário. Instale a versão mais recente de Python gerida pelo uv:

uv python install

Isto instala a versão mais recente disponível no uv no momento da configuração. Para uma versão específica do projeto, use o fluxo de pinning no meu guia rápido para gerir Python no macOS com uv.

Instale pyenv separadamente apenas quando precisar do seu método de compilação a partir do código-fonte:

brew install pyenv

Uso pyenv quando preciso de um interpretador compilado a partir do código-fonte ou de opções de compilação personalizadas do CPython que as distribuições pré-compiladas do uv não fornecem. Remova pyenv da lista de plugins abaixo se ignorar esta instalação opcional.

Escolher um terminal

O Terminal predefinido do macOS é suficiente. Usei iTerm2 durante anos e mudei recentemente para Warp, um terminal baseado em Rust com funcionalidades de AI integradas. A escolha não afeta a configuração posterior.

Se continuar a usar iTerm2, estas são as duas definições que altero:

Ativar a edição de texto natural

  1. Abra Preferences → Profiles → Keys → Key Mappings.
  2. Abra a lista pendente Presets….
  3. Selecione “Natural Text Editing”.

Escolher um tema de cores

  1. Consulte os temas em iTerm2-Color-Schemes.
  2. Abra Preferences → Profiles → Colors → Color Presets…
  3. Selecione Import e escolha o tema descarregado.

Configurar Zsh

O macOS usa Zsh como shell de login predefinida. Uso a /bin/zsh incluída; instale a Zsh do Homebrew apenas quando precisar de uma versão upstream mais recente específica.

Verifique a Zsh instalada e a shell de login atual:

echo "$SHELL"
command -v zsh
zsh --version

Se a Zsh estiver instalada mas não estiver selecionada como shell de login, mude para a cópia incluída:

chsh -s /bin/zsh

Abra um terminal novo depois de alterar a shell de login.

O Oh My Zsh adiciona as predefinições e o sistema de plugins que uso. O instalador padrão segue uma branch que está sempre a avançar. Para uma configuração pinned, faça clone sem fazer checkout dessa branch, selecione o commit analisado e só depois copie o template:

(
    set -e
    omz_dir="$HOME/.oh-my-zsh"
    if [ -L "$HOME/.zshrc" ]; then
        printf 'Refusing to replace symlink: %s\n' "$HOME/.zshrc" >&2
        exit 1
    fi
    if [ -e "$HOME/.zshrc" ] && [ ! -f "$HOME/.zshrc" ]; then
        printf 'Refusing to replace non-regular file: %s\n' "$HOME/.zshrc" >&2
        exit 1
    fi
    if [ -e "$HOME/.zshrc" ]; then
        omz_backup="$(mktemp "$HOME/.zshrc.pre-oh-my-zsh.XXXXXX")"
        cp "$HOME/.zshrc" "$omz_backup"
        printf 'Existing .zshrc backed up to %s\n' "$omz_backup"
    fi
    git clone --filter=blob:none --no-checkout https://github.com/ohmyzsh/ohmyzsh "$omz_dir"
    git -C "$omz_dir" checkout --detach 4b657407c98bbc8830ae66c2ac7ff3d737c55a83
    test "$(git -C "$omz_dir" rev-parse HEAD)" = 4b657407c98bbc8830ae66c2ac7ff3d737c55a83
    new_zshrc="$(mktemp "$HOME/.zshrc.new.XXXXXX")"
    trap 'rm -f "$new_zshrc"' EXIT
    cp "$omz_dir/templates/zshrc.zsh-template" "$new_zshrc"
    test -s "$new_zshrc"
    test ! -d "$HOME/.zshrc"
    mv -f "$new_zshrc" "$HOME/.zshrc"
)

O bloco para antes de substituir .zshrc se o clone ou a verificação do commit falhar. Recusa symlinks e ficheiros que não sejam regulares, cria uma cópia de segurança de um ficheiro existente com um nome .zshrc.pre-oh-my-zsh.* único e substitui-o por uma cópia temporária verificada através de uma única operação de rename. Compare a cópia de segurança apresentada com o template e restaure as suas definições locais antes de abrir uma shell nova. O checkout está pinned no commit 4b65740; atualize o hash apenas depois de analisar uma revisão mais recente.

Execute os snippets de configuração da shell a partir de uma única shell de configuração, sem outro processo a editar .zshrc ou os destinos do plugin e do tema. Estes recusam destinos existentes ou com symlinks, mas não são um package manager multiprocesso.

Adicionar plugins

Instale zsh-autosuggestions e zsh-syntax-highlighting no diretório de plugins personalizado do Oh My Zsh:

install_pinned_zsh_repo() (
    set -e
    repo_url="$1"
    commit="$2"
    destination="$3"
    if [ -L "$destination" ]; then
        printf 'Refusing symlink destination: %s\n' "$destination" >&2
        return 1
    fi
    if [ -d "$destination/.git" ] && [ "$(git -C "$destination" rev-parse HEAD)" = "$commit" ]; then
        return 0
    fi
    destination_parent="$(dirname "$destination")"
    mkdir -p "$destination_parent"
    stage="$(mktemp -d "$destination_parent/.pinned-zsh.XXXXXX")"
    cleanup_stage() { rm -rf "$stage"; }
    trap cleanup_stage EXIT
    git clone --filter=blob:none --no-checkout "$repo_url" "$stage/repo"
    git -C "$stage/repo" checkout --detach "$commit"
    test "$(git -C "$stage/repo" rev-parse HEAD)" = "$commit"
    test ! -e "$destination"
    test ! -L "$destination"
    mv -h -n "$stage/repo" "$destination"
    test ! -e "$stage/repo"
    test "$(git -C "$destination" rev-parse HEAD)" = "$commit"
)

install_pinned_zsh_repo https://github.com/zsh-users/zsh-autosuggestions e52ee8ca55bcc56a17c828767a3f98f22a68d4eb "${ZSH_CUSTOM:-$HOME/.oh-my-zsh/custom}/plugins/zsh-autosuggestions"
install_pinned_zsh_repo https://github.com/zsh-users/zsh-syntax-highlighting.git db085e4661f6aafd24e5acb5b2e17e4dd5dddf3e "${ZSH_CUSTOM:-$HOME/.oh-my-zsh/custom}/plugins/zsh-syntax-highlighting"

O commit pinned do zsh-autosuggestions e o commit pinned do zsh-syntax-highlighting correspondem às releases publicadas v0.7.1 e 0.8.0. Atualize os hashes apenas depois de analisar uma release mais recente.

Edite ~/.zshrc para os carregar com os plugins que uso:

plugins=(
    aws bgnotify brew docker docker-compose
    emoji forklift gcloud git history iterm2
    keychain kubectl macos pre-commit
    pyenv pylint python screen themes
    tmux virtualenv vscode
    zsh-autosuggestions zsh-syntax-highlighting
)

Mantenha zsh-syntax-highlighting como último elemento do array. A wiki de plugins do Oh My Zsh descreve os plugins incluídos. Os dois plugins externos sugerem comandos do histórico e realçam os comandos à medida que os escreve; siga as instruções de instalação em cada repositório.

Adicionar Powerlevel10k e o respetivo tipo de letra

O Powerlevel10k é o tema de Zsh que uso. Mostra o diretório de trabalho, o estado do Git e o ambiente Python ativo no prompt, além de fornecer um assistente interativo de configuração. Instale-o para o Oh My Zsh e selecione depois o tema em ~/.zshrc:

(
    set -e
    p10k_dir="${ZSH_CUSTOM:-$HOME/.oh-my-zsh/custom}/themes/powerlevel10k"
    if [ -L "$p10k_dir" ]; then
        printf 'Refusing symlink destination: %s\n' "$p10k_dir" >&2
        exit 1
    fi
    if [ -d "$p10k_dir/.git" ] && [ "$(git -C "$p10k_dir" rev-parse HEAD)" = 35833ea15f14b71dbcebc7e54c104d8d56ca5268 ]; then
        exit 0
    fi
    test ! -e "$p10k_dir"
    p10k_parent="$(dirname "$p10k_dir")"
    mkdir -p "$p10k_parent"
    stage="$(mktemp -d "$p10k_parent/.pinned-p10k.XXXXXX")"
    cleanup_stage() { rm -rf "$stage"; }
    trap cleanup_stage EXIT
    git clone --filter=blob:none --no-checkout https://github.com/romkatv/powerlevel10k.git "$stage/repo"
    git -C "$stage/repo" checkout --detach 35833ea15f14b71dbcebc7e54c104d8d56ca5268
    test "$(git -C "$stage/repo" rev-parse HEAD)" = 35833ea15f14b71dbcebc7e54c104d8d56ca5268
    test ! -L "$p10k_dir"
    mv -h -n "$stage/repo" "$p10k_dir"
    test ! -e "$stage/repo"
    test "$(git -C "$p10k_dir" rev-parse HEAD)" = 35833ea15f14b71dbcebc7e54c104d8d56ca5268
)

O commit pinned do Powerlevel10k é referenciado pela release v1.20.0.

Os IDs de objetos Git acima impedem alterações silenciosas de versão depois de os obter; não autenticam, por si só, o maintainer. Estes comandos confiam no endpoint HTTPS do GitHub e nas contas dos repositórios correspondentes. Para um modelo de confiança mais forte, verifique uma tag ou commit assinado contra uma chave do maintainer obtida separadamente antes de mover o checkout preparado para o local definitivo.

ZSH_THEME="powerlevel10k/powerlevel10k"

Abra uma shell nova e execute p10k configure.

Se usar o terminal integrado do VS Code, instale o tipo de letra recomendado antes de definir o tipo de letra do terminal, para que os ícones do Powerlevel10k sejam apresentados corretamente. p10k configure pode instalar automaticamente o tipo de letra no iTerm2. Noutros terminais, descarregue e instale os quatro ficheiros TTF do guia de tipos de letra do Powerlevel10k.

No VS Code, defina o tipo de letra do terminal como MesloLGS NF:

  1. Abra as definições do editor.
  2. Procure terminal.integrated.fontFamily.
  3. Defina-o como MesloLGS NF.

Escolher editores e assistentes de AI

Mantenho um IDE aberto e uma ou duas ferramentas de AI ao lado.

IDEs

  • Cursor é um fork do VS Code com pair programming de AI integrado.
  • VS Code tem um catálogo de extensões maior.

Assistentes de AI

  • OpenAI Codex é o coding agent da OpenAI.
  • Claude é o assistente da Anthropic, a que recorro para tarefas mais difíceis.

Atualmente, uso o Cursor com o Codex e o Claude Code a correr em paralelo.

Escolher containers e ferramentas de modelos locais

As ferramentas restantes dependem do trabalho que planeio fazer na máquina:

Docker Desktop e os executores de modelos locais são escolhas independentes. Instale-os quando os seus projetos precisarem de containers ou de inferência local; a configuração da shell e de Python não depende de nenhum deles.

Registar os limites da configuração

Esta é uma configuração pessoal, não uma baseline mínima ou universal do macOS. Remova o que não utilizar. Regista revisões de bootstrap e releases de plugins analisadas, mas as formulas do Homebrew e as aplicações GUI continuam a evoluir. As partes que mantenho consistentes são os limites:

  1. Use a /bin/zsh incluída, exceto quando um projeto precisar de uma Zsh mais recente específica.
  2. Use uv para a instalação diária de Python e para os ambientes dos projetos; mantenha pyenv para interpretadores CPython compilados a partir do código-fonte ou personalizados.
  3. Mantenha documentados os comandos de instalação, dotfiles sem segredos, extensões do editor e localizações dos modelos, para que a próxima configuração seja mecânica.

Referências