The Future of Work Is Here, Waiting to Be Claimed

The same black window sits open on my screen at home and at work. At home, I move through it fast. I set up the build, approve each change as it comes, and let the commands run because I trust the rhythm I have built inside it over months of reps.

At work, that rhythm was gone. Before I started, I had set the tool to ask my permission before it changed anything, and that setting was the only reason I caught what happened next. I was laying out the architecture for a new build, setting up folders, when the tool asked to start making changes on its own. Instead of approving it the way I would have at home, I stopped and read up on what that permission actually granted before letting a tool reach that far into a machine that was not mine.

Nothing about the tool had changed. The responsibility had.

The Lessons Ran Backwards

My employer recently opened access to the same AI coding tools I use at home, and I partnered with my engineering team to get set up. I work in a regulated industry, so the access came wrapped in rules, and the rules deserve respect. Building with company resources means governing yourself harder than curiosity ever demands. When the tools and the tokens belong to someone else, that governance is simply the right thing to do.

The version of Claude Code I had access to lives only in the terminal, and that constraint turned out to be a gift. It forced me to ask my engineering partners different questions, better questions, about how to set myself up to succeed. Those questions produced a folder structure on my machine and a project setup I could carry from build to build, one that other tools like Cursor plug into cleanly.

Then the constraint taught me something about my own garage. For years I had built cloud-first. Nearly every project I ran at home lived in Claude Projects, ChatGPT Projects, or GitHub, and my code went straight up to the cloud without any structure underneath it on my own machine. The cloud was my source of truth. The terminal forced the opposite, local files as the ground I stood on with AI layered on top, and that different foundation made me think and build in ways my own projects never had.

Terminal Only, On Purpose

One week of those lessons was enough to change how I build at home. I downloaded Claude Code in the terminal for the first time, on my own machine and on my own time. Then I made a commitment to myself, terminal only, no matter what I was building. No wrapper, no familiar buttons, no escape hatch back to the comfortable version.

I made that commitment for more than the discipline it would build. I believe the work of traditional engineers and knowledge workers is blending together, visible today in small pockets in any industry outside of tech. People who have never touched a code base will describe what they need in plain language, shape working prototypes with AI, and hand them to engineers to deploy. The skills companies hired for five years ago already look different from the skills the next five will reward.

Underneath the shift, the frameworks hold steady. Identify problems, build the solution, iterate, move fast, sell your vision, and drive measurable results. How the work gets done is evolving in real time.

Hold that belief, and the timing answers itself. The future of work is here, waiting for workers to claim it. Nobody schedules that moment for you, and no employer hands it over in an onboarding packet. Discomfort has been my tuition since my first rep, and the terminal is where the current semester is held.

I had reached into the terminal once before, for a single build, and left it there when the project shipped. This commitment asks for something that first reach did not. Every build from now on starts in the same demanding place, whether or not an easier path is one click away. Choosing discomfort on purpose is the only way I have ever grown, and I would rather train for the future than read about it.

Building for One Is the Easy Part

The commitment rearranged everything behind it. My entire Google Drive folder structure was rebuilt around how these projects will grow over time. My production system runs on written plans and gates, and multiple projects run on auto-mode with my judgment saved for the checkpoints that matter. Each build is a rep, logged the way a runner logs miles. The pattern is the point, reps against a future I can see coming.

At work the same muscles are pointed at other people. I want to build tools that make my team more creative, the kind that take busy work and repetitive tasks off their plates and unlock time for the work that actually matters. Giving my team time back matters more to me than any personal build shipping on schedule.

Every tool I build at home serves an audience of exactly one. That is the harder truth underneath the ambition. Nobody asks how access works, nobody needs training, and nobody has to trust my code but me. The moment I want a teammate to use something I built, the difficulty changes species. Deployment, access, permissions, and other people's trust turn a working tool into a shipping problem, and I am still early in learning how to solve it.

The real work now is building something a teammate can trust, and every private rep at home is practice for it.

Claim It With One Command

I do not know how the world shifts from here. I cannot tell you how quickly employers will integrate AI, which tools will win, or which skills the next hiring cycle will reward. I have stopped needing to know. I am building for the end state no matter how we get there. The reps travel, and so does the judgment they build. Whatever the future of work turns out to look like, the person who has been training for it will recognize it first.

If any part of this sounds out of reach, I want to hand you the smallest possible beginning. You do not need a project or a single line of code. You need the terminal, a program already sitting on the computer in front of you. On my Mac it is a plain dark square called Terminal. Open yours, type curl parrot.live, and press Return. A parrot made of keyboard characters will start dancing across your screen, streamed to you by a stranger on the internet for no reason except joy.

When the dancing is done, press Ctrl+C and the stream stops. That is the whole exercise, thirty seconds from start to finish, and you controlled both ends of it. You started something in the terminal, watched it run, and shut it down on your own terms. Every build I have shipped began with exactly that much courage.

Do not fear the terminal. The future of work is already running inside it, and it answers to whoever shows up. Claim it.