There’s a moment in every engineering organization’s AI journey that goes something like this: someone hooks up an AI agent to a codebase, it writes some code that looks plausible, and a room full of smart people starts asking uncomfortable questions. Who approved that change? What did it cost? Can we stop it if it goes wrong? Is there an audit trail? What happens when it hallucinates a database migration?
The industry is moving fast on AI-powered code generation. Agents that can read a ticket, plan an implementation, write the code, and open a pull request — that’s not science fiction anymore. The capability is real. But capability without governance is a demo. It’s not something you can hand to a VP of Engineering and say “trust this with your production codebase.”
That gap — between what AI agents can do and what organizations will actually let them do — is where I’ve been spending most of my time. And it’s why I started Artificer Digital.
A bit about me
I’m Tim Schiller. I’ve been building software professionally for 18 years, currently as a senior developer at ThoughtFarmer, where I work on intranet and collaboration platforms used by organizations around the world. That’s given me a deep appreciation for what it takes to ship real products at scale — the messy, unglamorous parts that don’t make it into blog posts. Deployment pipelines, data migrations, incident response at 2 AM, the slow accretion of technical debt and the even slower work of paying it down.
Over the course of the last year, I started noticing that the way I used AI in my development work was evolving from “help me write this function” to something much more interesting: orchestrating multi-step autonomous workflows where AI agents do substantive engineering work under human oversight. Not autocomplete — actual task execution.
That led me to found Artificer Digital. The company has two threads running in parallel. The first is Artificer Forge, an autonomous software development platform I’m building. Forge connects to your issue tracker — GitHub Issues or Jira — generates an implementation plan for human approval, then autonomously writes the code and opens a pull request. The interesting part isn’t the code generation. It’s everything around it: per-task budget tracking, kill switches, audit trails, multi-tenant isolation, and real-time observability via MQTT streaming. The governance layer.
The second thread is The Artificer’s Grimoire, a weekly newsletter where I curate developments in autonomous AI agents, context engineering, and orchestration. If you’re a practitioner in this space, it’s a good way to stay current without drowning in noise.
Why governance is the hard part
Most of the public conversation about AI coding agents focuses on capability benchmarks. Can the agent pass this coding interview? Can it solve this competitive programming problem? Can it build an app from a single prompt?
Those are interesting questions, but they’re the wrong ones for anyone trying to deploy this in a real engineering organization. The right questions are:
Cost control. If an agent gets stuck in a loop, how much money does it burn before someone notices? Forge tracks token spend per task and enforces hard budget ceilings. When the budget is hit, the task stops. No surprises on the bill.
Human authority. The agent should never be the final decision-maker. Forge generates implementation plans that humans review and approve before any code is written. The agent proposes; the human disposes.
Observability. When an agent is working on a task, you need to see what it’s doing in real time — not after the fact. Forge streams execution events via MQTT so you can watch the agent think, and intervene if it’s heading in the wrong direction.
Audit trails. Every decision the agent makes, every file it touches, every API call — logged and traceable. When something goes wrong (and it will), you need to be able to reconstruct exactly what happened and why.
Kill switches. Sometimes you just need to stop everything, right now. Not “please finish your current step and then stop.” Now.
None of this is glamorous. None of it makes for a compelling demo. But it’s the difference between a toy and a tool, and it’s what I think about most of the work I do.
What to expect from this site
This site is where I write about what I’m learning and building. The posts will generally fall into a few categories:
Technical deep dives on AI orchestration architecture, context engineering, and the infrastructure patterns that make autonomous development work at a systems level. AWS Step Functions, Bedrock, CDK, observability pipelines — the real implementation details, not hand-waving.
Industry commentary on where autonomous development is heading, what’s working, what’s hype, and what the implications are for engineering organizations and the people who work in them.
Building in public — the honest experience of going from senior IC at an established company to building a product and a business, including the decisions, trade-offs, and mistakes along the way.
Practical guides born from real implementation work, not theory. The kind of thing I wish I could have found when I was figuring it out.
Coming soon: Initiative-Driven Development
The first substantial thing I’ll be publishing here is a methodology I’ve been developing called Initiative-Driven Development (IDD). It addresses a problem that anyone who has tried to use AI agents for large-scale development work has encountered: the agent loses coherence across sessions.
You can get an AI agent to do excellent work within a single session. But real engineering initiatives — the kind that span weeks, touch multiple bounded contexts, and require architectural decisions — don’t fit in one session. Context windows reset. The agent forgets what it decided yesterday. Work drifts from the plan.
IDD is a context engineering methodology that solves this with a structured document hierarchy — Initiatives, Phases, Milestones, and Waves — where each level acts as a context reset boundary. It’s how I plan and execute everything at Artificer Digital, and it’s been genuinely transformative for the kind of multi-session AI-assisted work that most people find frustrating.
More on that soon. If you want to be notified when it drops, the best way is to follow me on LinkedIn or subscribe to The Artificer’s Grimoire.
If you’re working in this space — building AI agents, integrating them into engineering workflows, or just trying to figure out what autonomous development means for your team — I’d love to hear from you. You can find me on GitHub, LinkedIn, or reach me at tim@artificerdigital.com.