TSmithCode AI Workstation Profiler

Repeatable workstation profiling for serious AI developers.

This repo turns a new Mac or developer workstation into an auditable proof surface: hardware profile, installed tools, local model readiness, practical benchmarks, install recommendations, and public reports saved as Markdown and JSON.

Built by TSmithCode.ai for AI development, local models, CAD/BIM/GIS automation, containers, and performance-minded delivery.

Absolute Ceiling Standard

This is the public workstation proof kit I use to turn a high-end machine into evidence people can inspect, repeat, and trust.

The standard is simple:

• one command to profile the machine
• one command to benchmark practical developer workflows
• one command to generate a public-safe report
• one safety gate before publishing
• no hidden setup story
• no private-path leaks
• no benchmark screenshots without reproducible scripts behind them

For peers, this repo is a starting point for profiling a new workstation. For clients and hiring teams, it shows how I think: inspect the environment, measure the baseline, automate the repeatable pieces, and leave behind proof.

Why This Repo Exists

Most workstation videos stop at specs.

This repo asks better questions:

• What machine am I actually on?
• What tools and apps are installed?
• Can it run local AI workflows?
• Can it run containers?
• Can it run CAD/BIM/GIS-adjacent tooling?
• What benchmark results can a peer repeat?
• What is missing, and what should be approved before installing?

The point is not to win a synthetic benchmark leaderboard. The point is to prove operational readiness.

One-Command Demo

git clone https://github.com/tsmithcode/tsmithcode-ai-workstation-profiler.git
cd tsmithcode-ai-workstation-profiler
./scripts/run_live_demo.sh

That single demo runs the profiler, benchmark suite, recommendation pass, and public report generator, then saves a transcript for review.

The demo writes all generated artifacts to:

results/

Generated results are ignored by Git so you can review them before sharing.

What It Produces

After a run, you get:

• profile_*.md and profile_*.json
• benchmarks_*.md and benchmarks_*.json
• install_recommendations_*.md and install_recommendations_*.json
• public_workstation_report_*.md
• live_demo_transcript_*.txt

These files are designed for:

• YouTube screen recording
• GitHub proof artifacts
• Machine-to-machine comparison
• New workstation setup review
• Consulting discovery and trust-building
• Recruiter/hiring-manager proof of execution discipline

Fastest Viewer Path

If you are watching the video or reviewing this repo cold, use this sequence:

./scripts/check_release_safety.sh
./scripts/run_live_demo.sh
open results

Read the newest generated Markdown files first. Open the matching JSON only if you want raw machine-readable detail.

What The Profiler Checks

Machine Profile

• macOS version
• Model identifier
• CPU
• Physical and logical cores
• Memory
• Disk capacity and free space
• Relevant installed apps
• Relevant CLI tools
• Local Ollama model list, when available

Practical Benchmarks

• Single-core CPU SHA256 throughput
• Multi-core CPU SHA256 throughput
• Python memory copy bandwidth
• Local sequential disk write/read sanity check

Optional Workflow Checks

These run if the tools exist:

• Docker container execution
• QGIS processing provider
• GDAL version
• PDAL version
• Blender CLI version
• Ollama local model response

Missing optional tools are reported honestly. The scripts do not fake success.

Install Recommendations

Run:

./scripts/recommend_installs.py

This script recommends only. It does not install.

That is intentional. Serious workstation setup should be:

• visible
• auditable
• approval-first
• repeatable
• reversible

Command Reference

./scripts/profile_machine.py
./scripts/benchmark_machine.py
./scripts/recommend_installs.py
./scripts/generate_public_report.py
./scripts/run_live_demo.sh
./scripts/check_release_safety.sh
./scripts/build_release_zip.sh

You can also use:

make demo
make profile
make benchmark
make recommend
make report
make zip

Recommended Recording Flow

This repo includes a one-person creator workflow for a polished YouTube video:

• Director's Treatment
• Filming Runbook
• One-Person Crew Briefing
• Zero-Drift Action Checklist
• YouTube Package

The on-camera command is:

./scripts/run_live_demo.sh

The creative intent:

This is not a laptop review. This is a proof artifact.

Repo-To-Video Workflow

The repo is structured so the same assets support three surfaces:

• GitHub: repeatable public scripts and docs
• YouTube: live on-screen commands, transcript, and director notes
• TSmithCode.ai: a trust-building proof asset for machine readiness, performance discipline, and AI/CAD automation focus

For the one-person recording checklist, start here:

./scripts/start_recording_session.sh

That command opens the key docs and runs the safety gate so recording begins from the same sequence every time.

Benchmark Methodology

The benchmark suite is designed for high-ROI peer profiling:

• fast enough to run live
• simple enough to understand
• portable enough for peers
• useful enough to reveal readiness
• saved as Markdown and JSON

See Benchmark Methodology for what the numbers mean, what they do not mean, and how to compare results responsibly.

Privacy And Sanitization

This repo does not collect credentials, browser history, email, project files, SSH keys, API keys, or environment variable dumps.

Reports sanitize:

• home paths
• hostnames
• user-specific /Users/<name> paths

See Privacy And Sanitization.

Quality Gate

Before publishing or recording, run:

./scripts/check_release_safety.sh

The safety gate checks:

• scripts are executable
• public files do not leak private local markers
• generated result folders are ignored
• release zip builds
• release zip validates

See Quality Gate.

Who This Is For

This repo is useful for:

• AI developers setting up a new machine
• local model builders
• CAD/BIM/GIS automation developers
• technical founders documenting their workstation
• recruiters or hiring managers evaluating execution discipline
• consulting buyers who want proof that the operator can measure and systematize

TSmithCode Positioning

This project reflects how TSmithCode approaches technical work:

1. Inspect the environment.
2. Measure the baseline.
3. Automate the workflow.
4. Save the evidence.
5. Recommend changes by approval.
6. Leave behind a repeatable system.

That is the point of this profiler.

Trust Contract

This repo is intentionally opinionated:

• It favors repeatable local commands over one-off screenshots.
• It separates recommendations from installs.
• It treats missing tools as useful signal instead of failure.
• It keeps generated results out of source control by default.
• It makes privacy and sanitization part of the release process.

That is the bar for anything I want associated with TSmithCode.ai.

Repository Structure

.
├── docs/        Human guidance, methodology, filming notes, privacy, quality gate
├── examples/    Public-safe examples and sample result guidance
├── results/     Local generated outputs, ignored by Git except .gitkeep
├── scripts/     CLI profiler, benchmark, report, recommendation, safety, release tools
├── Makefile     Short command aliases
├── README.md    Project entry point
└── LICENSE      MIT license

License

MIT. Use it, fork it, and benchmark your own workstation.