by piomin
AI Software Factory running on Kubernetes / OpenShift with Tekton and vLLM
# Add to your Claude Code skills
git clone https://github.com/piomin/ai-software-factoryGuides for using ai agents skills like ai-software-factory.
See how ai-software-factory compares with popular alternatives.
ai-software-factory is an open-source ai agents skill for AI coding assistants such as Claude Code, Codex CLI, and ChatGPT, built by piomin. AI Software Factory running on Kubernetes / OpenShift with Tekton and vLLM. It has 76 GitHub stars.
ai-software-factory's catalog security scan is still queued. You can run an instant dependency and prompt-injection check now with the "Scan for vulnerabilities" button above.
Clone the repository with "git clone https://github.com/piomin/ai-software-factory" and add it to your Claude Code skills directory (see the Installation section above).
ai-software-factory is primarily written in Dockerfile. It is open-source under piomin on GitHub, so you can review or fork the full source.
Yes. SkillsLLM lists many other AI Agents skills you can browse and compare side by side. Open the AI Agents category from the badge at the top of this page, or use the Related Skills and comparison links further down to weigh ai-software-factory against similar tools.
No comments yet. Be the first to share your thoughts!
Available after the catalog security scan passes.
⚠️ Third-Party Software Notice
This skill is third-party open-source software developed and hosted independently on GitHub. SkillsLLM lists this project for discovery and does not control or maintain the underlying repository.
Any security checks, ratings, or warnings displayed by SkillsLLM are automated and limited in scope. They do not constitute a security certification or guarantee that the software is safe, error-free, or free from malicious code, vulnerabilities, compromised dependencies, or prompt-injection risks.
Review the source code, permissions, dependencies, and configuration before installing or running any third-party skill. Use is at your own risk. To the maximum extent permitted by applicable law, SkillsLLM is not liable for losses arising from third-party software.
The deep catalog scan for this skill is still queued. Run an instant dependency check now instead.
A self-hosted "software factory" that turns GitHub issues and comments into pull requests. GitHub events are received by Tekton Triggers, executed as Tekton pipelines, and handled by a coding agent (OpenCode) that talks to an open model served by vLLM on GPU nodes in the same cluster. Nothing leaves the cluster except the calls to GitHub.
The factory at a glance: GitHub, Tekton on OpenShift, the coding agent and the model on vLLM.
GitHub (issue, comment, review)
│ webhook
▼
OpenShift Route ──► EventListener (Tekton Triggers)
├─ github interceptor (HMAC signature check)
└─ cel interceptor (who / what / which event is allowed)
│
TriggerBinding ─► TriggerTemplate ─► PipelineRun
│
┌─────────────────────────────────────────┘
▼
print-event ─► fetch-skills ─► prepare ─► plan ─► agent ─► verify ─► publish
│ │ │ │ │ │
OCI artifact clone + plan as OpenCode build, commit, push,
(skills, agents) branch comment + vLLM test, fix PR, reply
(Qwen)
| Pipeline | Triggered by | What happens |
|---|---|---|
issue-agent |
a new issue (issues / opened) |
Posts a checklist plan as an issue comment, implements the issue on a new branch, opens a pull request, enables auto-merge and replies with a summary. |
issue-comment-agent |
an issue comment starting with @ai |
Treats the comment as an instruction. A question gets an answer; a change request gets a plan, a branch and a pull request. |
pr-comment-agent |
a pull request review or review comment | Reads the whole PR conversation, pushes the requested change to the PR branch (or answers a question) and replies on the PR. |
Every trigger only accepts events from users whose author_association is OWNER or MEMBER
and ignores bots. Forks and closed issues or pull requests are skipped.
| Technology | Why |
|---|---|
| Kubernetes / OpenShift | One platform for everything: pipelines, agents and models. Each agent run is an isolated pod, so many agents run in parallel and the scheduler places them. GPU nodes, secrets, RBAC and network policies come built in. |
| Tekton | Kubernetes-native CI. Tekton Triggers turn a GitHub webhook straight into a PipelineRun, with signature checks and CEL filters. Every run is a recorded object that can be retried, logged and timed. |
| vLLM | High-throughput inference with continuous batching, so parallel agents share one GPU deployment. It serves an OpenAI-compatible API, supports tool calling and tensor parallelism, and runs open models in the cluster. |
| Open model (Qwen) | Code and issue text never leave the cluster, there is no per-token cost, and you can swap the model by changing one config entry. |
| OpenCode | Open-source coding agent that works with any OpenAI-compatible endpoint, so it does not tie the factory to a single model vendor. Permissions are declared in a config file. |
| GitHub App | Short-lived installation tokens instead of personal access tokens, with fine-grained permissions and its own bot identity. |
| OCI artifact for skills | Skills and subagents are versioned and pulled from the same registry as images, with no extra infrastructure. |
The approach described here is in use in a sample application repository:
piomin/ai-software-factory-showcase.
The GitHub App from this guide is installed there, and the repository has an AGENTS.md with the
rules the agent follows. Browse its closed issues and merged pull requests to see the factory at
work: the plan comment on a new issue, the pull request opened by the bot, the human approval and
the auto-merge. The GitHub screenshots in this README come from that repository.
Each diagram follows one event from GitHub through the OpenShift cluster (Route, EventListener,
PipelineRun in the agents namespace) to the model on vLLM (ai namespace) and back to GitHub.
The numbers show the order of the main interactions. The orange-framed steps (plan, agent) are
where the coding agent runs: OpenCode, which the pipelines use, or the optional Claude Code image.
Quay.io only serves the skills artifact. The OpenCode and Claude Code icons are simplified
drawings, not the official logos.
.
├── agents/ the agent: images and shared configuration
│ ├── Dockerfile.opencode reference Dockerfile of the agent image (the pipelines pull it from Quay)
│ ├── Dockerfile same tooling with Claude Code (optional, not used by the pipelines)
│ └── configmap-agent-config.yaml OpenCode config (model, permissions) and the GitHub App token script
├── tekton/ pipelines and everything that triggers them
│ ├── pipeline-*.yaml the three Tekton pipelines
│ ├── triggerbinding-*.yaml map webhook payloads to pipeline parameters
│ ├── triggertemplate-*.yaml create the PipelineRuns
│ ├── eventlistener-new-issue.yaml the single EventListener with four triggers and their filters
│ ├── task-*.yaml shared tasks: fetch-skills, verify-build, report-failure
│ ├── resourcequota-agents.yaml optional cap on parallel runs
│ ├── route-new-issue.yaml public HTTPS endpoint for the GitHub webhook
│ └── serviceaccount-*.yaml, rolebinding-*.yaml service account and RBAC for the EventListener
├── secrets/ secret skeletons with placeholders only (never commit real values)
│ └── secret-github-app.yaml, secret-github-webhook-secret.yaml, secret-hf-token.yaml, ...
├── ai/ the model: cache volume, Deployment and Service for qwen38-flash and qwen3-coder
└── docs/
├── diagrams/ SVG diagrams of the three event flows
└── images/ screenshots used in this README
Namespaces used: ai for models and agents for pipelines and triggers.
ai/ requests 2 GPUs
(--tensor-parallel-size=2), 180 GiB of memory and a 300 GiB cache volume. Both deployments
ship with replicas: 0; run only one at a time unless you have 4 GPUs.nvidia.com/gpu:NoSchedule taint. If you taint your GPU nodes
differently, change the tolerations in ai/.StorageClass that supports ReadWriteOnce (the manifests use gp3-csi).registry.redhat.io for the vLLM images (the cluster pull secret normally covers it).Install from OperatorHub, in this order:
NodeFeatureDiscovery
instance (the defaults are fine). It labels nodes that have NVIDIA hardware.ClusterPolicy. It installs
the driver, container toolkit and device plugin on GPU nodes.github and cel cluster interceptors and the pipeline service account.
Installed Operators: Node Feature Discovery, NVIDIA GPU Operator and Red Hat OpenShift Pipelines.
Verify:
# GPU nodes are discovered and advertise GPUs
oc get nodes -l feature.node.kubernetes.io/pci-10de.present=true
oc describe node <gpu-node> | grep -A2 'nvidia.com/gpu'
# Tekton is running
oc get pods -n openshift-pipelines
oc get clusterinterceptors
A GPU node with the nvidia.com/gpu resource in its capacity and allocatable lists.
oc, optionally tkn and gh. podman and oras are only needed if you build your own agent
image or publish your own skills artifact (section 4).
oc new-project ai
oc new-project agents
Create a GitHub App (Settings, Developer settings, GitHub Apps) with:
github-webhook-secret).
Repository permissions of the GitHub App: Contents, Pull requests and Issues set to read and write.
*Events the app subscribes to: Issues, Issue comment, Pull