Zach Lloyd writes about building software factories: systems that use AI agents and supporting infrastructure to increase software development throughput.
A software factory should be an open, composable stack defined in code.
Judge a factory by throughput, measured in human touches per pull request.
Integrations are configuration, and work should start where people already talk.
Check first: Confirm audience composition, reach and engagement data, media kit, rate card, and sponsorship formats.
Main ideas
A software factory should be an open, composable stack defined in code · Keep the data and ability to verify inside your own walls · Judge a factory by throughput, measured in human touches per pull request
Audience
18,744 LinkedIn followers · 4 posts published between 23 September and 7 October 2026 Posts in reviewed sample
Zach Lloyd writes about software factories: systems that use AI agents and supporting infrastructure to increase software-development throughput.
In the reviewed LinkedIn posts, they explain the idea through a layered infrastructure model, practical measures such as human touches per pull request, and examples of how factory workflows connect to tools like Microsoft Teams and Azure DevOps.
Follow this work for a concrete view of how teams might design, measure, and adopt these systems.
Lloyd connects architectural principles to operational choices.
The infrastructure post moves layer by layer—from version-controlled factory configuration and context to compute, inference, improvement, orchestration, and access—and explains how openness and composability support testing and rollback.
Other posts make the discussion concrete: one proposes tracking human touches per pull request, while another lists specific Teams and Azure DevOps workflows.
Some material is product-focused, including a Warp Factories feature announcement; an event post frames adoption questions such as crawl, walk, or run, build versus partner, and which metrics to track.
Together, these examples help readers look beyond agent demos to the systems and measures needed to run software factories.
Zach Lloyd's posts argue that companies should treat agent-driven software development as an engineered system—a "software factory"—rather than a loose collection of AI tools.
Read more
Their recurring priorities: define the factory in version-controlled configuration, keep the stack open enough to swap models, hosts, and agents, measure success in throughput rather than features shipped, keep context data and verification under your own control, and let agents start work inside the tools teams already use. A panel announcement with engineers from Uber and Faire extends the argument to adoption phases, build-versus-partner decisions, and culture.
A software factory should be an open, composable stack defined in code
Lloyd lays out software factories as layered infrastructure, with a job for each layer: factories-as-code at the base; a context layer (internal MCPs and CLIs, agent memories, conversation and access logs, agent rules and skills); a compute layer of remote, pausable environments; an inference layer that swaps between frontier and open-weight models and different agent harnesses; improvement infrastructure; orchestration for launching agents and steering live sessions; and access points through UIs, a direct MCP, and third-party surfaces such as code forges.
Read more
They define three terms directly: open means the stack works with any model, agent, and hosting configuration; composable means a team can adopt part or all of it and use the pieces however it wants; defined in code means factory state is versioned, testable, and revertible.
The aim is to let a team tune quality, cost, and speed over time without rebuilding the whole system.
Versioning makes benchmarking, A/B testing, and rollbacks possible.
A version-controlled file such as factory.yaml holds agent configuration, runners, repository access, external integrations like Slack and Jira, webhooks from Grafana and Sentry, and automation triggers such as crons, taskboard changes, and pull request updates. Lloyd calls the approach "Terraform for factories."
Keep the data and ability to verify inside your own walls
Two conditions run through Lloyd's stack description.
Read more
The first is data control: if a team uses a third-party context layer, it should be able to store all that layer's data on its own infrastructure, no outside provider should train on it, and zero data retention is a must.
The context layer holds agent memories, skill files, conversation and access logs, and rules—the raw material the factory runs on and the record of how it behaves.
The second is verification: Lloyd wants computer-use models connected to remote development environments to test the apps agents build, enabling reproduction, verification, and prototyping.
Together, these conditions make a team's ability to inspect and trust what its factory produces central to its usability.
Lloyd calls zero data retention "a must" for third-party context storage. They describe computer-use models testing agent-built applications inside remote dev environments as a way to reproduce and verify their output.
Judge a factory by throughput, measured in human touches per pull request
Lloyd frames the shift in software engineering as a move from building the product to improving the factory, with a single efficiency measure to watch: human touches per pull request, which should fall over time.
Read more
They also name the wider set: DORA-style metrics such as cost per PR, and qualitative measures like code quality and efficiency scored by an LLM acting as a judge.
The numbers close the improvement loop.
Agents find their own failure points and suggest skill improvements, while test suites with varied configurations measure how model and harness combinations perform on real work.
Measurement becomes a recurring practice, not a one-off report.
"One measure of factory efficiency is 'human touches per pr.' Over time you want to drive this down." Lloyd pairs that with cost-per-PR and LLM-as-a-judge quality scoring in their stack post.
Integrations are configuration, and work should start where people already talk
Lloyd's Microsoft Teams and Azure DevOps announcement applies the code-defined pattern to enterprise surfaces: integrations, agents, triggers, and automations are declared as version-controlled configuration rather than clicked into a console.
Read more
The flexible-infrastructure argument is that agents should be able to run from anywhere.
They detail the mechanics: mentioning agents from work items and pull requests, triggering automations from work item and PR events, giving each factory its own identity for Git and pull request operations, working across selected repositories with scoped access, and shipping pull requests back through Azure DevOps.
In Teams, users start by mentioning the app in an existing channel or thread; it keeps context as work moves from conversation to implementation and follows up in-thread while agents work.
The post is also a vendor announcement: it positions the product as first in the industry to support the full Microsoft suite, offers early access and up to $10,000 in free factory usage for eligible teams, and bases its strongest claim on the company's own statement.
Teams evaluating the open-stack argument should ask whether the Microsoft suite remains an optional piece of a stack they control.
A team mentions a Warp agent inside an existing Teams channel or thread. The agent carries that context into implementation, and the finished pull request comes back through Azure DevOps for review.
Adoption is phased and cultural, not just technical
Lloyd advertised a panel with Adam Huda, a senior engineering manager at Uber, and Christopher Handel, director of product for the AI platform at Faire, to compare notes on adopting software factories.
Read more
The announced agenda is operational rather than conceptual: what each phase looks like in practice and how to tell whether you are in crawl, walk, or run; how to architect the factory stack across runners, environments, scorers, benchmarks, and quality gates; when to build versus partner; which metrics to track, including human touchpoints per change, cost per unit of software shipped, and governance signals; and the cultural changes needed to make the system stick.
The panel was scheduled for October 8, with registration through a link in the post; the post itself contains no summary of what the participants concluded.
Answers “What are the components of a software factory?” and gives newcomers a blueprint.
Read more
Zach Lloyd outlines a layered architecture for software factories: factories-as-code, data and context, compute, inference, improvement, orchestration, and access.
Each layer has specific requirements, including version-controlled configuration (like factory.yaml), zero data retention for context, pausable compute, and support for any model.
The post argues that an open, composable, code-defined stack enables benchmarking, rollbacks, and continuous improvement.
For brands planning a campaign
A developer tools company could use this as the basis for an architecture guide or technical webinar, mapping its product to each layer and offering a practical implementation path.
Shows how software factories are being productized and embedded in enterprise tools, especially the Microsoft stack.
Read more
This post announces that Warp Factories now integrates with Microsoft Teams and Azure DevOps.
It details features such as mentioning agents from work items, triggering automations, scoped repository access, and shipping pull requests back through Azure DevOps.
It emphasizes that these workflows are part of Factories as Code, so integrations and triggers are version-controlled.
It also mentions up to $10,000 in free factory usage for eligible teams.
For brands planning a campaign
Highlights how integrations can drive adoption. A campaign could focus on connecting factory infrastructure to existing workflows, or offer a guide to building composable integrations.
Answers “How do you measure a software factory’s efficiency?” and introduces a concrete metric for tracking progress.
Read more
Zach Lloyd argues that software engineering is shifting to “factory engineering,” where the focus is on improving throughput rather than just building the product. They introduce “human touches per PR” as a measure of factory efficiency, with the goal of driving it down over time.
For brands planning a campaign
A campaign focused on metrics and benchmarking could resonate. For example, a webinar on measuring factory efficiency or a guide to tracking human touches per PR.
Offers a roadmap of practical adoption questions and points to a live discussion with engineering leaders.
Read more
Zach Lloyd announces an October 8 event with Adam Huda (Uber) and Christopher Handel (Faire) to discuss adopting software factories.
The post lists discussion topics: phases of adoption (crawl/walk/run), architecting the factory stack (runners, environments, scorers, benchmarks, quality gates), build-versus-partner decisions, metrics like human touchpoints per change and cost per unit shipped, and cultural changes.
Registration is via a link.
For brands planning a campaign
A developer tools company could sponsor or co-host a similar event, or create a guide organized around these adoption phases and decisions.
Software factories as a layered infrastructure stack
Zach Lloyd's central argument is that a software factory—a system where AI agents carry out development work—should sit on an open, composable stack defined in code.
Read more
Their long post breaks that stack into layers and gives each one a job: factories-as-code at the base; a context layer (internal MCPs and CLIs, agent memories, conversation and access logs, agent rules and skills); a compute layer where agents run in remote environments that can pause and resume; an inference layer that can swap between frontier and open-weight models and different agent harnesses; improvement infrastructure; orchestration for launching agents and steering live sessions; and access points through UIs, a direct MCP, and third-party surfaces like code forges. The layered design lets teams change quality, cost, and speed over time without rebuilding the whole system.
For brands planning a campaign
A developer-tools company can build an architecture guide or technical webinar around this layer map: Lloyd's posts already provide the outline and vocabulary. The sponsoring vendor can position its product at one or two named layers rather than claim the entire stack, with Lloyd as a credible co-author.
Lloyd repeatedly argues that agent infrastructure should be defined in version-controlled configuration.
Read more
Their example is a file such as factory.yaml holding agent configuration, runners, repository access, external integrations like Slack and Jira, webhooks from Grafana and Sentry, and automation triggers such as crons, taskboard changes, and pull request updates. They describe versioning as the feature that enables benchmarking, A/B testing, and rollbacks, and call the approach 'Terraform for factories.' The Microsoft Teams and Azure DevOps announcement applies the same pattern, presenting integrations, agents, triggers, and automations as configuration rather than settings clicked into a console.
Lloyd uses an analogy to a tool developers already know (Terraform), then lists the concrete contents of a configuration file, making the idea testable rather than abstract.
For brands planning a campaign
This is the corpus's most hands-on theme and the best fit for a collaboration that produces something usable, such as a downloadable starter configuration or a walkthrough of a factory definition. A vendor can sponsor the artifact alongside a webinar, giving the campaign a concrete asset rather than a general interview.
Lloyd frames the shift in software engineering as a move from building the product to improving throughput, and offers a specific unit of measurement: human touches per pull request, which should fall over time.
Read more
They also name the wider metric set, including DORA metrics such as cost-per-PR, qualitative measures like code quality and efficiency scored by an LLM as a judge, and test suites with varied configurations that benchmark model and harness combinations on real work. Their improvement loop uses those measurements to find failure points, suggest skill improvements, and compare configurations, turning measurement into a recurring practice rather than a one-off report.
For brands planning a campaign
A developer-tools company selling observability, CI, or evaluation products can put metrics at the center of a webinar or benchmarking report with Lloyd. The specific measures they name—human touches per PR, cost-per-PR, and LLM-as-a-judge quality scoring—give the campaign measurable claims to build content around.
One post is a product announcement rather than an argument: Warp Factories adding Microsoft Teams and Azure DevOps support, described as the first in the industry to cover the full Microsoft suite across software factory work.
Read more
The listed capabilities are concrete: mentioning agents from work items and pull requests, triggering automations from work item and PR events, giving each factory its own identity for Git and pull request operations, and shipping pull requests back through Azure DevOps. In Teams, the workflow starts with mentioning the app in an existing channel or thread, keeps context as work moves from conversation to implementation, and follows up in-thread while agents work.
This is the only promotional post among the four. It describes early access and up to $10,000 in free factory usage for eligible teams—a product offer, not a documented sponsorship or consulting rate. Ask for those rates separately. The post also calls the product first in the industry; treat that as the vendor's claim and ask for substantiation.
For brands planning a campaign
For a collaboration with a platform vendor—Microsoft-ecosystem tooling, chat platforms, or code forges—this post shows Lloyd speaking in the integration language buyers use, naming triggers, scoped repository access, and the handoff back to a human reviewer. A joint integration announcement plus a technical walkthrough is a natural campaign shape.
Practical adoption: phases, build-versus-partner, and culture
Lloyd hosted a discussion with Adam Huda, a senior engineering manager at Uber, and Christopher Handel, director of product for the AI platform at Faire, to compare notes on adopting software factories.
Read more
The announced agenda is unusually operational: what each phase looks like in practice and how to tell whether you are in crawl, walk, or run; how to architect the factory stack across runners, environments, scorers, benchmarks, and quality gates; when to build versus partner; which metrics to track, including human touchpoints per change, cost per unit of software shipped, and governance signals; and the cultural changes needed to make the system stick. The post points readers to a registration link, inviting them into a live practitioner conversation rather than offering a conclusion.
Lloyd teaches through practitioner comparison, pairing their framing with named engineers from other companies to test it against real adoption experience.
For brands planning a campaign
A webinar or panel collaboration best matches both what Lloyd already does and what they say they want to discuss. A devtools company can supply the practical segment—architecture, build-versus-partner criteria, or metric definitions—while Lloyd and a customer engineer carry the adoption narrative, keeping the session useful to teams still deciding whether to start.
Zach Lloyd's posts are tied to Warp, whose Factories product they announce in the first person and link to at warp.dev/factories.
Read more
Their posts also name Microsoft as a newly supported platform across Warp Factories workflows, and, in a separate post, Uber and Faire as the employers of two engineers joining a conversation they hosted about adopting software factories.
Warp
Employment
Lloyd announces Warp Factories releases in the first person, writing that "we're the first in the industry to support the full Microsoft suite across software factory workflows," and links readers to warp.dev/factories for early access and up to $10,000 in free factory usage for eligible teams.
Read more
They speak on behalf of the company; ask for their job title if it matters to your campaign.
Warp Factories added support for Microsoft Teams and Azure DevOps: mentioning agents from work items and pull requests, triggering automations from work item, PR, and channel events, giving each factory its own Git identity, and shipping pull requests back through Azure DevOps.
An October 8 session Lloyd hosted on adopting software factories featured Adam Huda, a senior engineering manager at Uber, alongside a product director from Faire.
Lloyd's writing is a good place to start if you want to understand what people mean by a "software factory."
Read more
Begin with the long post on the layered stack: it defines open, composable, and defined-in-code, then walks through factories-as-code, context, compute, inference, improvement, orchestration, and access.
The next two posts narrow the argument to measurement—human touches per pull request, cost per PR, and quality scoring—and show how they judge whether an agent factory is working.
The Microsoft Teams and Azure DevOps announcement shows the same ideas landing inside an enterprise toolchain, while the panel post lists the adoption questions they think matter, from crawl-walk-run phases to build-versus-partner decisions.
For a wider view of the same territory, Cole Medin runs and teaches an open-source factory, Bartosz Jurga covers the security and recovery side of the delivery pipeline, and Darius Radford packages "software factory" as a security operating model.
Medin writes about the same central idea Lloyd calls a software factory: an issue goes in, a pull request comes out, a manager agent supervises parallel runs, and a human tests the batch in staging.
Read more
Both are working out how much autonomy is practical, and both see reliability and verification—not the model itself—as the hard part.
Medin works in the open, building an open-source factory people can download.
They describe a deliberate shift from teaching people to build things toward shipping something that works out of the box, with a video walkthrough to follow along.
Lloyd argues at the level of an infrastructure stack and vendor platform, where a versioned configuration file is the unit of design; Medin focuses on the loop they run themselves and the lessons it offers for making agents dependable.
Jurga covers the software delivery pipeline from the other direction: what a poisoned upstream dependency or compromised CI/CD runner does to an organization, and why supply chain risk and ransom decisions belong on the board agenda rather than in IT.
Read more
Readers following Lloyd for how to build a factory will find Jurga useful for understanding what inside it needs protection.
Jurga offers security and resilience advice for executives: trusted delivery pipelines as an entry point, blast radius and regulatory exposure, and immutable, air-gapped backups as the recovery answer.
The work also has a commercial brief behind it.
Lloyd's posts focus on designing, configuring, and measuring an agent factory, rather than risk governance, compliance, or recovery planning.
Radford also organizes software delivery around the phrase "software factory," with a vendor-neutral framework built from pillars that include orchestrated delivery and artifact and supply chain control.
Read more
Both writers treat the delivery pipeline as a system to structure and measure rather than a set of tools to buy one at a time.
Radford's factory is a security operating model: named pillars, a maturity index, an assessment method, and a phased roadmap for organizations that must explain application risk to executives. Lloyd's factory is where agents do the work; the posts focus on architecture, versioned configuration, and throughput rather than controls, compliance, or maturity scoring.
The posts support a LinkedIn-led placement for a developer-tools thought-leadership campaign.
Read more
The LinkedIn profile listing shows 18,744 followers as of 8 October 2026.
Four technical, practitioner-facing posts cover software-factory infrastructure: factory definitions kept in version control, remote dev environments, model and harness choice, cost and quality metrics, and integrations with Microsoft Teams and Azure DevOps.
For a technical webinar or architecture guide aimed at people already following software-factory content, the profile offers a plausible venue and a warm starting audience.
The posts do not identify the followers’ geography, age, seniority, job function, or company size, and provide no reach, impression, or engagement figures for individual posts.
Before committing budget, ask Zach Lloyd for recent results on technical posts comparable in depth and format to the planned webinar or architecture guide, and any audience survey covering job function, seniority, and geography.
Treat 18,744 as a ceiling on potential reach, not an estimate of actual reach.
The subject matter points to an engineering and engineering-leadership readership rather than a general business audience.
Four posts over roughly two weeks are too small a sample to establish which topics or formats perform best or how deep interest runs.
If no audience survey exists, plan the collaboration as a thought-leadership placement and judge it on post-level results rather than follower count.
Zach Lloyd’s posts in this evidence set announce products and events for Warp’s software-factory offering; they do not present creator sponsorship packages.
Read more
Across the four posts, there is no media kit, rate card, sponsored format, disclosure practice, or official partnership inquiry route.
The commercial signals are Warp’s Microsoft Teams and Azure DevOps integrations, an early-access offer of up to $10,000 in free factory usage for eligible teams, and a panel session with an engineering manager from Uber and a director of product from Faire.
For a technical webinar or architecture guide collaboration, treat these as evidence of what they promote and who they’ll share a stage with—not as standing partnership terms.
Confirm scope, deliverables, and pricing directly before making plans.
A developer-tools company wants to build thought leadership around software factories with a technical webinar and an architecture guide.
Read more
Zach Lloyd is a good fit.
The four posts provide a ready architecture spine: the layered stack from factories-as-code through context, compute, inference, improvement, orchestration, and access; the factory.yaml example; the “Terraform for factories” analogy; throughput measures such as human touches per PR and cost-per-PR; and Microsoft Teams and Azure DevOps integration language.
Those are the components a developer-tools sponsor needs for a useful webinar or guide.
The posts also show a teaching method built on concrete configuration and layered decisions rather than general AI commentary.
The panel post shows they will share a stage with named practitioners from Uber and Faire to discuss adoption phases, build-versus-partner questions, runners, environments, scorers, benchmarks, quality gates, and culture.
That closely matches a technical webinar for teams deciding whether to start.
The audience case is plausible but unproven: 18,744 LinkedIn followers observed on 8 October 2026 offer a warm starting audience, and the subject matter points to an engineering and engineering-leadership readership.
Before budgeting, ask for audience composition, reach and engagement data, a media kit or rate card, and the available sponsorship formats.
When to choose a specialist
A consumer wellness brand wants a high-volume awareness campaign built on short-form video, with a paid lifestyle creator delivering TikTok and Instagram posts and a guaranteed reach number.
Read more
Zach Lloyd is a poor fit.
The posts are technical written explanations of software factories, agent infrastructure, configuration files, integration triggers, throughput metrics, and adoption phases—not consumer lifestyle, product demonstrations, or entertainment.
They do not show short-form video, visual assets, consumer campaigns, or an audience suited to a wellness buyer.
The follower count is on LinkedIn and reflects an accumulated audience, not short-form video reach or engagement.
For this campaign, the content format and channel are the wrong fit.
Reconsider only if they can provide short-form video examples, audience demographics, and evidence that they can guarantee the required reach.
If the brand wanted to stay in the developer-tools space, the assessment would change.
A worked campaign example
Campaign angle for a developer-tools campaign: “Build the first layer of a software factory: a working architecture session and starter guide.”
The sponsoring developer-tools company co-hosts a 45-minute technical webinar with Zach Lloyd and a customer engineer.
The first 15 minutes use the layered stack from their long post—factories-as-code, context, compute, inference, improvement, orchestration, and access—to give attendees a shared map.
The next 15 minutes walk through a factory.yaml-style starting point: agent configuration, runners, repository access, Slack and Jira integrations, Grafana and Sentry webhooks, and cron or PR triggers.
The remaining time covers measurement: human touches per PR, cost-per-PR, LLM-as-a-judge quality scoring, and what to track before and after the first automation.
The sponsor’s product appears at one or two named layers—for example, the inference or improvement layer—rather than claiming the whole stack.
That keeps the session credible and gives the audience a concrete evaluation step.
The companion architecture guide reuses the structure as a downloadable outline with a blank configuration worksheet and a short benchmark checklist.
The campaign handoff is a next step: pick one layer, define the metric to move, run a two-week benchmark against current work, and decide whether to build or partner.
Lloyd is the right co-author or host because the posts already provide the outline and vocabulary, and they have panel experience; the sponsor supplies the practical segment and product-specific evaluation path.
Before launch, request post-level impressions and engagement for comparable technical posts, and confirm the collaboration scope and pricing.
Choose Cole Medin for the same developer-tools thought-leadership brief when the campaign should show what it takes to run an AI software factory, not just describe its layers.
Read more
The available posts describe a working loop: a GitHub issue in, a pull request out, each lap building one issue, testing the app as a user, reviewing code, and merging to staging only when CI is green.
They also cover release planning with 10–20 tickets, holdout test scenarios the builder never sees, a manager agent that pings when work is stuck, and human batch review in staging.
That makes Cole a fit for a build-in-public angle, a webinar on an open-source factory and lessons from operating one, or a guide for teams seeking an out-of-the-box starting point rather than a blank architecture.
Cole Medin also states that an open-source AI software factory is a priority, giving the campaign a concrete artifact for a demo or workshop.
The tradeoff is that Zach Lloyd's posts focus less on factory architecture and enterprise integration than the factory-building brief requires.
They center on one builder's loop, release planning, holdout tests, staging review, and an open-source project.
They don't use a layered stack vocabulary such as factories-as-code, context, compute, inference, improvement, orchestration, and access, or show Microsoft Teams or Azure DevOps workflows.
A sponsor choosing Cole Medin would need to supply the architecture backbone, governance framing, and measurement taxonomy, or accept a more personal, practitioner-led story about learning to build and run a factory.
Ask for the referenced video and repository before relying on them to demonstrate depth or audience.
Choose Bartosz Jurga when the developer-tools company wants to lead with security, governance, or board-level risk inside software factories.
Read more
The posts cover a package compromise and a campaign that infected more than 400 packages with more than 500 million weekly downloads.
They argue that perimeter defense is irrelevant if attackers enter through trusted delivery pipelines.
They address CEOs, CISOs, and CTOs on blast radius, deployment secrets, compliance exposure under NIS2 and ISO 27001, business continuity, and ransomware decisions.
Recommendations include version pinning, least-privilege pipeline access, automated credential rotation, immutable backups, air-gapped storage, and tested recovery.
This is a stronger alternative when the technical webinar or guide should focus on securing the factory and recovering from supply-chain attacks, rather than configuring agents and runners.
The tradeoff is weaker relevance to the build-side software factory conversation.
Bartosz Jurga's posts don't cover factory.yaml, model and harness choice, context layers, orchestration, human touches per PR, or the build-versus-partner phases this brief calls for.
Choosing Bartosz Jurga would shift the promise from “how to build a software factory” to “how to protect and recover one,” likely requiring a different sponsor product placement, audience promise, and architecture guide outline.
Ask for the linked executive briefs and audience and commercial data before committing to this direction.
Choose Darius Radford when the sponsor wants a named operating model and assessment offer around secure software factories, rather than the factory-building stack.
Read more
The posts describe a Secure Software Factory framework with four capability pillars — orchestrated delivery, developer-centric application security, artifact and supply chain control, and unified risk correlation — and a 2.0 version that adds post-deployment protection, with AI governance across the model.
They also reference WeAreDevelopers World Congress North America sessions on the agentic software factory and explain why faster pipelines and AI-generated code increase the need to verify dependencies, enforce policy, understand risk, and protect production.
The assessment path examines how an organization builds, tests, packages, deploys, and operates software, then sets a maturity baseline and roadmap.
It suits a webinar or guide for security and platform leaders seeking a structured way to start.
The tradeoff is that this is security-governance content with a commercial assessment offer, not a neutral technical architecture session.
The posts emphasize maturity pillars, assessments, and post-deployment protection; they don't walk through agent configuration, runners, context storage, inference choices, or throughput metrics such as human touches per PR.
A sponsor would get a credible governance frame but need to supply or co-create the practical factory-building layer.
The campaign may also read more like a vendor-adjacent operating-model pitch than the Zach Lloyd material.
Ask for the referenced whitepaper, event session, and assessment conversation to evaluate their depth and audience.
Zach Lloyd's four LinkedIn posts describe a layered software factory stack, throughput measures, Warp Factories support for Microsoft Teams and Azure DevOps, and an October 8 panel with engineers from Uber and Faire.
The posts do not include publication dates or a year for the panel, and no transcripts, slides, or audience data appear in the posts here.
Similar creators Cole Medin (September 3 and October 16, 2026), Bartosz Jurga (August 31 and September 21, 2026), and Darius Radford (March 25 and September 29, 2026) each have two written posts.
A LinkedIn account listing gives 18,744 followers as of October 8, 2026.
No books, shows, or earlier career details are mentioned here; those details remain unestablished.
