DEV GENIUS·
Book a Discovery call

DEV Genius · by BotSmith

An AI dev on your team, with engineering discipline.

Takes an idea, asks what's unclear, and delivers Pull Requests with spec, tests and live QA — from idea to merge, always with human review.

Book a Discovery callSee how it works ↓
questions to the teamapplyQA queueTICKETDESIGNPULL REQUESTCODE REVIEWQAMERGE

The standard agile flow, from refinement to merge — and it adapts to your team's process and phases.

At least 3x faster, from case to merge.

< USD 3 in Claude API cost per task delivered.

What DEV Genius is

DEV Genius is an agent you orchestrate from Slack over isolated cloud sandboxes, with your project's repositories already cloned and a full environment ready to run and test real code.

It's not code autocomplete: it's a complete delivery flow. It analyzes the task, drafts the spec, writes the code with tests, opens the Pull Requests and leaves a browsable QA environment to test the change before merging.

It runs on your infrastructure and your credentials, never the other way around: your keys, your data, your infrastructure.

Integrates with your stack

  • Slack
  • ClickUp
  • Jira
  • GitHub
  • GitLab
  • Vercel

Slack as the control room and your tracker as the source of truth: the pipeline adapts to your team's process and phases, not the other way around.

How it works

The full cycle runs from idea to merge, and every phase stays visible in a Slack thread: nothing moves forward without the team seeing it.

DEFINE

From idea to ticket

The AI researches the code and the system's living documentation and drafts the full ticket in the team's tracker: context, scope and acceptance criteria. Built for product, no code knowledge required.

  1. You describe the idea in a Slack thread

    Someone from product opens a thread and describes what's needed, no commands or technical jargon.

  2. Research against the real system

    The AI reviews the project's code and documentation before proposing anything; if a similar ticket already exists in the backlog, it flags it with the link.

  3. Business questions, not technical ones

    Open questions come back numbered in the thread, only about scope and business rules. They get answered and re-analyzed until none remain.

  4. Stories and acceptance criteria

    If the idea is large, it's broken into coordinated stories; each one gets its own scope and acceptance criteria, ready to be picked up.

ASK

Nothing moves forward blind

Before a single line is written, technical questions reach the devs and business questions reach the product team, always over Slack.

  1. Technical questions to the devs

    Whatever isn't clear about the code or architecture gets asked in the thread, straight to the team's devs.

  2. Business questions to product

    Whatever depends on a product decision gets tagged to the right team, also in the thread.

  3. The plan is approved before building

    Nothing starts coding until the open questions are resolved and the work plan is approved.

IMPLEMENT

Spec, tests, code

In an isolated cloud sandbox, spec comes before code and the project's own checks are the quality gate.

  1. Isolated cloud sandbox

    An ephemeral environment is provisioned with the project's repositories, ready to run and test real code.

  2. Spec before code

    Proposal, design and task plan are drafted and approved before writing a single line.

  3. TDD, task by task

    Each task in the plan is implemented tests first, code second.

  4. The project's checks are the gate

    Existing linters, pre-commit and CI decide whether the change passes, not the agent's judgment.

DELIVER

PRs, QA and merge

The delivery is left ready to review and test, and the project's knowledge base updates itself on close.

  1. One PR per repository

    With tests included and a description ready to review.

  2. Browsable QA environment

    Every delivery spins up its own ephemeral environment with a URL to test the change live.

  3. Human code review

    A dev reviews and approves, or requests changes, before anything reaches the main branch.

  4. Merge and learning

    On merge, the project's living documentation updates itself, leaving the next task with fewer open questions.

parallel track

Large workloads

Not another phase of the cycle: a separate track for epics, workloads that group weeks of work into a series of coordinated tickets.

  1. Breakdown into a ticket series

    The large workload is split into small, verifiable tickets with explicit dependencies between them.

  2. Execution subtask by subtask

    The agent moves one subtask at a time, without waiting for manual intervention between one and the next.

  3. Independent evaluator

    Each subtask is checked against its acceptance criteria before being integrated into the workload's branch.

  4. Green CI as the gate

    Nothing gets integrated without the project's checks passing; failures are deferred or block the workload per the defined policy.

Capabilities

Knowledge isn't lost, it accumulates

Every task delivered leaves the project's knowledge more complete, and that knowledge lets the next task start with fewer open questions. No one documents by hand.

workspace-specs

The specs corpus

A repository of specs reverse-engineered from the code and the project's real history, that feeds itself: every delivery produces its spec delta as a byproduct and, on merge, an automatic process validates it, archives it and integrates it into the corpus.

That corpus is cloned into every new sandbox. The AI researches it before asking, so its questions arrive already grounded and its proposals rest on the project's real history of decisions.

knowledge graph

The second brain

On top of the corpus, a browsable knowledge graph is maintained, with one note per product concept linked to its related specs and lessons. It regenerates itself with every delivery.

That graph is useful for onboarding new people and for the AI itself to discover connections a text search wouldn't find.

Principles and safety

  • Spec before code

    No feature is built without an approved proposal, design and plan. The process lives in the orchestrator, not in the model's judgment.

  • TDD and quality gates

    Tests first, and the project's linters, type-checkers and suites have to pass before delivery.

  • Real isolation

    The agent runs in a cloud sandbox, never on the team's machines; it's destroyed once the task is done.

  • Humans in charge

    A dev reviews and approves every Pull Request; the agent never merges on its own.

Who's behind it

Saúl Hernández, founder of BotSmith

Saúl Hernández

Agentic Engineer, founder of BotSmith SpA

15 years building software — from intern in Caracas to Dev Lead at Recorrido.cl.

This past year I stopped using AI to code faster and built a system where the AI codes and the pipeline guarantees the quality.

DEV Genius is the result, and it's running in production today.

saul.botsmith.aiLinkedInsaul@botsmith.ai

Frequently asked questions

Your backlog is longer than your capacity. Let's change that.

Book a Discovery call: we'll review your team's current flow and define the pilot together.

Book a Discovery call