I've been playing with loads of AI coding tools the last few months and while the tools themselves are evolving rapidly, my knowledge of the limitations and the right ways to work with them have really leveled up what I'm getting out of them.
I've just deployed the first few versions of a pretty complex little blob of code implementing a bulletin board system running on the Meshcore mesh networking system. Meshcore runs over seriously bandwidth constrained radio links: 184 byte message payload limits, really slow link speeds at the radio layer (~1.7 kbit/s on the typical settings used in Sydney). Claude investigated and planned out an architecture to make this work and made intelligent suggestions.
The process worked like this:
- Outline the setup and how I'd like to deploy it, what I wanted from it and how users would connect (I'll drop the initial prompt down the bottom of the post)
- Claude comes back with deep insight into the limitations of the network, the architecture I'm planning and brings up things I hadn't thought of like spam, abuse and network overload considerations
- I ask it to write a detailed spec including all the architecture and components
- The initial spec includes a whole section of unresolved questions which I answer and it finalises the spec.
- I move the spec into a new chat and direct it to build the thing.
- Claude outputs a tar file with the full thing.
All this was done on my phone while lying in bed. I went to sleep that night and the following morning dropped the tarball into a directory and pointed Claude Code at it. Build the docker container, install on my Unraid server, connect up a Meshcore device and get serial routed to the container.
Bam. Up and running. And it works really quite well!
Unbelievable.
Further iterations were a bit clunky with me having to deploy the containers manually and going through the config loop more than once. I worked out a better flow using Github Actions to build the containers and deploy them to a container store that Unraid can reload. Turning into a nice workflow.
What I'm now thinking through and will start experimenting with is getting a really tight process for doing these kinds of projects that neatly migrates straight into an easy production workflow. I toyed with this a bit on my FBI Radio apps using Linear for issue management, Cursor for coding agents and Github actions for build and delivery.
So I'm evolving towards a workflow that looks something like this:
- Initial spec in an LLM output to Markdown
- Migrate into Cursor with Linear upstream
- Cursor agents build the app
- Deployments go to Github PRs which are built and test by Cursor agents
- PRs merged manually which builds the production artifacts
- I've used Railway a bit for deployment here
What's blowing my mind is the quality of the agents in these processes. Not just at writing the code but building the deployment pipelines, testing the code, reviewing it and making quite good suggestions and changes.
We are in an interesting world. Knowing a bit about coding and coding workflows sure is becoming a superpower.
That initial prompt:
I want to set up a Meshcore bulletin board system that users can access through direct messages. It could provide services such as news headlines, quick weather info, public message boards with persistence and messages to other users that are asynchronous.
The idea would be that messages to and from an individual user would be their unique stream connecting them to the BBS. Authentication would just be their public key used to sign their DMs. If in understanding how DMs work correctly.
How would I get this set up? I'm thinking of running it in a VM on my unraid server with a serial connection to a Meshcore companion device. It could use the Meshcore python library to connect.
https://github.com/meshcore-dev/meshcore_py
Build me an outline of how this would work. Highlight any potential issues or things I haven't thought of.