James Whiteneck

Software Engineer. Husband, father of two, and avid sports and crypto fan.

[James Whiteneck @JamesWhiteneck]

@chongdashu Yeah. Not sure if you’ve tried that at all and was curious.

[James Whiteneck @JamesWhiteneck]

@chongdashu Have you tried or had any luck with terrain?

[James Whiteneck @JamesWhiteneck]

@burkeholland Always feed any complex plan to multiple models. They all find and push on different aspects, yields much better results. Then also have them “Review with fresh eyes”. You’d be surprised how well that works too.

[James Whiteneck @JamesWhiteneck]

@jeet_exist @pierceboggan @pierceboggan is codex models super terse in Copilot CLI on purpose? I’ll ask to deep dive into something and I’ll get 5 sentences and 1 paragraph. Opus will give me 5 pages. Codex cli will give 3-5.

[James Whiteneck @JamesWhiteneck]

@doodlestein Cannot wait for this one 🔥

[James Whiteneck @JamesWhiteneck]

@chongdashu This has been a huge unlock, it's crazy being able to connect from your phone. Makes it so much harder to disconnect. One thing that might be helpful is sharing any configurations and tips you have for using tmux and terminus on your actual phone, it can be tricky at first.

[James Whiteneck @JamesWhiteneck]

@DannyLimanseta Holy smokes. That’s incredible. Time to go update my tools

[James Whiteneck @JamesWhiteneck]

@LLMJunky Will definitely make good use of this. Thanks!

[James Whiteneck @JamesWhiteneck]

@DannyLimanseta This is insanely impressive. Got to the Forgotten Catacombs before I got wiped out

[James Whiteneck @JamesWhiteneck]

@DannyLimanseta Awesome! Can’t wait to try it.

[James Whiteneck @JamesWhiteneck]

@DannyLimanseta @manofyear93 Barely scratching the surface but this is so much fun

[James Whiteneck @JamesWhiteneck]

@DannyLimanseta @manofyear93 This is so damn cool. I told Google Studio to build me the same thing and it did. Time to tweak and play with it but the possibilities are awesome.

[James Whiteneck @JamesWhiteneck]

@_Evan_Boyle @doodlestein https://t.co/rj8lZODX6a

[James Whiteneck @JamesWhiteneck]

@_Evan_Boyle Have you seen/considered @doodlestein ‘s new Frankentui?

[James Whiteneck @JamesWhiteneck]

@burkeholland @github Oh snap, this is incredible. I do this manually when creating plans and reviewing all the time. This is going to be so useful 🤯

[James Whiteneck @JamesWhiteneck]

@SebAaltonen Awesome! How are you handling the image generation?

[James Whiteneck @JamesWhiteneck]

@doodlestein Thanks for sharing!

[James Whiteneck @JamesWhiteneck]

@mattpocockuk @doodlestein constructs very detailed plans up front and by all accounts has been very productive. I'm sure you've seen his stuff but in case not, highly recommend https://t.co/wbxu0eMqab

[Jeffrey Emanuel @doodlestein]

If you have a markdown plan for a new piece of software that you're getting ready to start implementing with a coding agent such as Claude Code, before starting the actual implementation work, give this a try.

Paste your entire markdown plan into the ChatGPT 5.2 Pro web app with extended reasoning enabled and use this prompt; when it's done, paste the complete output from GPT Pro into Claude Code or Codex and tell it to revise the existing plan file in-place using the feedback:

---
Carefully review this entire plan for me and come up with your best revisions in terms of better architecture, new features, changed features, etc. to make it better, more robust/reliable, more performant, more compelling/useful, etc.

For each proposed change, give me your detailed analysis and rationale/justification for why it would make the project better along with the git-diff style changes relative to the original markdown plan shown below:

<PASTE YOUR EXISTING COMPLETE PLAN HERE>
---

This has never failed to improve a plan significantly for me. The best part is that you can start a fresh conversation in ChatGPT and do it all again once Claude Code or Codex finishes integrating your last batch of suggested revisions.

After four or five rounds of this, you tend to reach a steady-state where the suggestions become very incremental.

(Note: I was originally planning to end this post here, but thought it would be helpful for people to see this part in the larger context of the entire workflow I recommend using all my tooling)

Then you're ready to turn the plan into beads (think of these as epics/tasks/subtasks and associated dependency structure. The name comes from Steve Yegge's amazing project, which is like Jira or Linear, but optimized for use by coding agents), which I do with this prompt using Claude Code with Opus 4.5:

---
OK so please take ALL of that and elaborate on it more and then create a comprehensive and granular set of beads for all this with tasks, subtasks, and dependency structure overlaid, with detailed comments so that the whole thing is totally self-contained and self-documenting (including relevant background, reasoning/justification, considerations, etc.-- anything we'd want our "future self" to know about the goals and intentions and thought process and how it serves the over-arching goals of the project.) Use only the `bd` tool to create and modify the beads and add the dependencies. Use ultrathink.
---

After it finished all of that, I then do a round of this prompt (if CC did a compaction at any point, be sure to tell it to re-read your AGENTS dot md file):

---
Check over each bead super carefully-- are you sure it makes sense? Is it optimal? Could we change anything to make the system work better for users? If so, revise the beads. It's a lot easier and faster to operate in "plan space" before we start implementing these things! Use ultrathink.
---

Then you're ready to start implementing. The fastest way to do that is to start up a big swarm of agents that coordinate using my MCP Agent Mail project.

Then you can simply create a bunch of sessions using Claude Code, Codex, and Gemini-CLI in different windows or panes in tmux (or use my ntm project which tries to abstract and automate some of this) in your project folder at once and give them the following as their marching orders (for this to work well, you need to make sure that your AGENTS dot md file has the right blurbs to explain each of the tools; I'll include a complete example of this in a reply to this post):

---
First read ALL of the AGENTS dot md file and README dot md file super carefully and understand ALL of both! Then use your code investigation agent mode to fully understand the code, and technical architecture and purpose of the project. Then register with MCP Agent Mail and introduce yourself to the other agents.

Be sure to check your agent mail and to promptly respond if needed to any messages; then proceed meticulously with your next assigned beads, working on the tasks systematically and meticulously and tracking your progress via beads and agent mail messages.

Don't get stuck in "communication purgatory" where nothing is getting done; be proactive about starting tasks that need to be done, but inform your fellow agents via messages when you do so and mark beads appropriately.

When you're not sure what to do next, use the bv tool mentioned in AGENTS dot md to prioritize the best beads to work on next; pick the next one that you can usefully work on and get started. Make sure to acknowledge all communication requests from other agents and that you are aware of all active agents and their names. Use ultrathink.
---

If you've done a good job creating your beads, the agents will be able to get a decent sized chunk of work done in that first pass. Then, before they start moving to the next bead, I have them review all their work with this:

---
Great, now I want you to carefully read over all of the new code you just wrote and other existing code you just modified with "fresh eyes" looking super carefully for any obvious bugs, errors, problems, issues, confusion, etc. Carefully fix anything you uncover. Use ultrathink.
---

I keep running rounds of that until they stop finding bugs. Eventually they'll need to do a compaction, so if they do that, right after hit them with this (note that I've been typing AGENTS dot md to avoid the annoying preview on X because it thinks it's a website; you can replace that with a period and remove the spaces if you want; the agents don't care either way):

---
Reread AGENTS dot md so it's still fresh in your mind. Use ultrathink.
---

When the reviews come up clean, have them move on to the next bead:

---
Reread AGENTS dot md so it's still fresh in your mind. Use ultrathink. Use bv with the robot flags (see AGENTS dot md for info on this) to find the most impactful bead(s) to work on next and then start on it. Remember to mark the beads appropriately and communicate with your fellow agents. Pick the next bead you can actually do usefully now and start coding on it immediately; communicate what you're working on to your fellow agents and mark beads appropriately as you work. And respond to any agent mail messages you've received.
---

When all your beads are completed, you might want to run one of these prompts:

---
Do we have full unit test coverage without using mocks/fake stuff? What about complete e2e integration test scripts with great, detailed logging? If not, then create a comprehensive and granular set of beads for all this with tasks, subtasks, and dependency structure overlaid with detailed comments.
---

or

---
Great, now I want you to super carefully scrutinize every aspect of the application workflow and implementation and look for things that just seem sub-optimal or even wrong/mistaken to you, things that could very obviously be improved from a user-friendliness and intuitiveness standpoint, places where our UI/UX could be improved and polished to be slicker, more visually appealing, and more premium feeling and just ultra high quality, like Stripe-level apps.
---

or

---
I still think there are strong opportunities to enhance the UI/UX look and feel and to make everything work better and be more intuitive, user-friendly, visually appealing, polished, slick, and world class in terms of following UI/UX best practices like those used by Stripe, don't you agree? And I want you to carefully consider desktop UI/UX and mobile UI/UX separately while doing this and hyper-optimize for both separately to play to the specifics of each modality. I'm looking for true world-class visual appeal, polish, slickness, etc. that makes people gasp at how stunning and perfect it is in every way. Use ultrathink.
---

And then start the process again of implementing the beads. When you're done with all that and have solid test coverage, you can then keep doing rounds of these two prompts until they consistently come back clean with no changes made:

---
I want you to sort of randomly explore the code files in this project, choosing code files to deeply investigate and understand and trace their functionality and execution flows through the related code files which they import or which they are imported by.

Once you understand the purpose of the code in the larger context of the workflows, I want you to do a super careful, methodical, and critical check with "fresh eyes" to find any obvious bugs, problems, errors, issues, silly mistakes, etc. and then systematically and meticulously and intelligently correct them.

Be sure to comply with ALL rules in AGENTS dot md and ensure that any code you write or revise conforms to the best practice guides referenced in the AGENTS dot md file. Use ultrathink.
---

and

---
Ok can you now turn your attention to reviewing the code written by your fellow agents and checking for any issues, bugs, errors, problems, inefficiencies, security problems, reliability issues, etc. and carefully diagnose their underlying root causes using first-principle analysis and then fix or revise them if necessary? Don't restrict yourself to the latest commits, cast a wider net and go super deep! Use ultrathink.
---

You should also periodically have one of the agents run this as you're going to commit your work:

---
Now, based on your knowledge of the project, commit all changed files now in a series of logically connected groupings with super detailed commit messages for each and then push. Take your time to do it right. Don't edit the code at all. Don't commit obviously ephemeral files. Use ultrathink.
---

If you simply use these tools, workflows, and prompts in the way I just described, you can create really incredible software in a just a couple days, sometimes in just one day.

I've done it a bunch of times now in the past few weeks and it really does work, as crazy as that may sound. You see my GitHub profile for the proof of this. It looks like the output from a team of 100+ developers.

The frontier models and coding agent harnesses really are that good already, they just need this extra level of tooling and prompting and workflows to reach their full potential.

To learn more about my system (which is absolutely free and 100% open-source), check out:

https://t.co/22Fy2w73x0

It include a complete tutorial that shows anyone how to get start with this process. You don't even need to know much at all about computers; you just need the desire to learn and some grit and determination. And about $500/month for the Claude Max and GPT Pro subscriptions, plus another $50 or so for the cloud server.

If you want to change the entire direction of your life, it has truly never been easier. If you think you might want to do it, I really recommend just immersing yourself.

Once you get Claude Code up and running on the cloud server, you basically have an ultra competent friend who can help you with any other problems you encounter.

And I will personally answer your questions or problems if you reach out to me on X or on GitHub issues (it might be Claude impersonating me though, lol).

[Jeffrey Emanuel @doodlestein]

In this new world we live in, where ideas and intelligence are plunging in marginal cost by the day, I really think one is better off focusing on creating as much value as possible overall instead of focusing on how much value you can personally capture for yourself.

Have an abundance mindset. Don't hoard methods or tools, share them. You will help others and they will appreciate it. And it will quickly come back to you in so many ways that you can hardly predict.

And anyway, the half-life of a hoarded method or tool now is like a few months at best. You're better off focusing on building great things, growing your skills and reputation in the world, and helping others improve alongside you.

Building in public has so many advantages. For one, the GitHub Actions are free! But seriously, if you're working in dev tooling, your public repos are themselves your very best advertisement and public irrefutable proof that your tools and workflows really do work.

Because otherwise, where the hell are all those commits and releases coming from?

And I would go even further (and have been): don't just commit the final code. Commit each revision as you go so people can watch the evolution. And don't just post the code, post the plans. And not just the final plans, all of the versions as you go. And not just the plans, the prompts you used to make and refine the plans.

If you commit those as part of the repo, people will notice that and appreciate it and learn from you. And you will get users who give you valuable feedback and bug reports that your agents can slurp up and use to polish your software ( I have a big post to write about this process, which I've totally automated now for myself).

And where does all that lead? Well, many if not most of your users will be regular people who can only give you some support and encouragement and appreciation. But don't underestimate how personally satisfying that can be. In psychic terms, that's pure gold.

Some smaller fraction of your users will themselves be smart devs who have really interesting insights and suggestions that you can leverage. You'd never even know who they are probably if you didn't share your stuff.

And some even smaller fraction of your users, if you are really making something useful, will be extremely successful and prosperous people who also have an abundance mindset and who can bring you opportunities that would never be available to you otherwise.

Truly, the more you give, the more you get. Just focus on giving good stuff. Take all that time and energy you spend jealously guarding your edge and proprietary methods and workflows and spend it moving faster and making better stuff in the open, and you might be shocked at how much better it feels and how much it helps your bottom line, too.

So many people I speak to about open source tell me ruefully that it's too bad I've given this all away because now anyone can just take my stuff and turn around and sell it. Well, good luck selling what is already free and open, first of all, especially when I'm going a million miles per hour to improve it all.

But also, when I do figure out how to provide a service that people do want to pay for (i.e., a hosted offering that is built entirely on the same open-source tooling but which layers on an intuitive web app and mobile app, which I've already finished the beads for), I will have a built-in audience that is receptive.

And yes, of course, someone else or some big company could fork all 20+ of my repos and try to rebadge and resell it all. But what are the chances that they're going to make something even close to as good as I can make when I'm the one who conceived of, designed, and implemented everything in 2 months?

Also, I strongly believe that many of the people I've helped along the way by being as open as I have been will then be happy to be patrons of my hosted offering, assuming it is a good service and a compelling value proposition, which I will ensure is the case.

Would they really want to switch to the ersatz knockoff version to save a few bucks? Knowing that it will always be behind my latest versions of the open source tooling?

I'd like to think not, but I guess we'll see. Stay tuned!

And btw, no matter what, I will never stop sharing and being open. Once you've see the light about this you never want to go back into the shadows, toiling in obscurity for illusory gold.