Dev & Engineering software-development-lifecycletest-driven-developmentcode-reviewsecurity-auditrelease-managementrequirements-engineeringdeveloper-workflows

Itqan Engineering

Run a disciplined software lifecycle with human approval gates, test-first implementation, and evidence-backed completion.

FollowAgents review · FARS-2.1
Recommended
80/ 100 5-point scale 4.0 / 5
1 2 3 4 5 6
Per-dimension scores and reasoning
1Trust24 / 29 · 4.1/5

The evidence shows explicit human gates before code and shipping, no autonomous triggering, no commits, pushes, or outward writes without approval, user choice over workspace visibility, and deliberately narrow CI permissions with commit-pinned actions. This strongly supports least privilege, confirmation, transparent data placement, and controlled external effects. Security routing for auth, PII, and payments and the rule against retaining raw PII are stated, but the supplied evidence omits the skill bodies needed to inspect the handling details. Rollback-first release is likewise chiefly a README claim. Dependency scanning is optional, advisory, and allowed to fail, while mkdocs-material uses a 9.* range, so dependency security is not complete. The license and named author establish basic attribution, but publisher identity remains unverified and the citation procedure is not shown in implementation.

2Reliability9 / 14 · 3.2/5

The lifecycle, approval ledger, resume semantics, and zero-test handling are internally coherent, while CI is configured to validate structure, the installer, and prescribed commands. However, the underlying skills, validation scripts, and test outputs are absent, preventing static confirmation that the behavioral promises are implemented throughout; enforcement also varies by runtime. Node requirements, alternate installation paths, graceful degradation, and an issue-reporting format are documented, but concrete failure branches and diagnostic-message examples are sparse. Dependency availability and failure messaging therefore receive adequate rather than full credit.

3Adaptability16 / 18 · 4.4/5

The source maps twelve skills to scenarios ranging from ambiguous discovery through construction, verification, release, security, design, assessment, and learning. It supplies selection rules, standalone invocation paths, a runtime matrix, and an explicit opt-in trigger field, making audience coverage, boundaries, and trigger precision strong. Multiple agents and installation modes are addressed, including Node requirements and fallback behavior. The claim of support for more than seventy agents and broad cross-runtime compatibility is not backed by the supplied compatibility list or implementation files, so environment fit is not fully evidenced.

4Convention15 / 18 · 4.2/5

The README has strong information hierarchy, a stable skill taxonomy, workspace layout, installation paths, invocation conventions, and pointers for removal and troubleshooting. Naming is consistent across its diagram, tables, and examples. The full MIT text is supplied, and limitations are unusually concrete, including 0.x instability, the weakness of recorded approvals, and prompt-injection boundaries. The Book, FAQ, and CONTRIBUTING content are only linked rather than supplied, so their depth cannot be assessed. No actual changelog or release history is included. The author, issue path, and contribution path are identifiable, but there is no explicit maintenance commitment, support window, or verified publisher identity.

5Effectiveness10 / 13 · 3.8/5

The proposed outputs—specifications, plans, decisions, ledgers, reviews, release evidence, and task-scoped archives—have clear locations and downstream uses, supporting high output usability. Resumable orchestration, approval gates, and evidence gates plausibly add value over isolated prompts, but most outcome claims remain first-party assertions without the skill bodies, complete sample artifacts, or independent comparisons. The Markdown-only design and fallback behavior suggest modest setup cost, yet token use, elapsed time, repeated-test cost, and workspace maintenance overhead are not quantified. Marginal value and cost-benefit are therefore scored conservatively.

6Verifiability6 / 8 · 3.8/5

Several claims point to inspectable mechanisms: disable-model-invocation fields, a suggested grep check, ledger structure, pinned CI actions, and narrowly declared workflow permissions. The license and workflows provide limited cross-file corroboration for ownership, permission discipline, and validation intent. Still, the core skill files, scripts, documentation chapters, demo artifacts, and CI results are not supplied, so most behavioral guarantees cannot be cross-checked. The README carefully distinguishes enforced behavior from procedure and fallback, labels suggestions and unknowns, and discloses a negative A/B result and human-gate limitations; this fully supports fact/inference separation within the available source.

Evidence confidence: Low Reviewed Sep 17, 2026 Reviewed revision 053f947e366b
Before you use it
  • This is a low-confidence static review; the installer, skills, tests, resume path, and release workflow were not executed.
  • The core SKILL.md files, CONVENTIONS.md, validation scripts, and full documentation were not supplied, so many runtime guarantees remain project assertions.
  • The dependency-security scan requires a secret, is advisory, and uses continue-on-error; it is not a merge gate.
  • Before adoption, inspect the curl-to-shell installer, actual write scope, outbound network behavior, PII handling, and commit/deployment gates.
  • The project explicitly identifies itself as 0.x; pin the reviewed revision and establish migration or rollback procedures before upgrading.
Review evidence [1][2][3][4]
See the full review method →

What does this agent do, and when should you use it?

Itqan is a model-agnostic suite of pure-Markdown engineering skills comprising one resumable orchestrator, six core lifecycle phases, and five specialist skills. Its main flow runs define, blueprint, construct, verify, inspect, and release, with separate human approvals for the specification and implementation plan. It reads the host repository and its conventions, implements changes test-first, reruns tests and examines their output, performs a read-only review, and produces a release verdict. The discover, design, harden, assess, and learn specialists cover product research, UI/UX work, security auditing, application assessment, and learning plans. Specifications, plans, reviews, change history, and phase state live in a persistent engineering/ workspace, while commits, pushes, and other outward writes remain outside the suite's autonomous boundary.

The root SKILL.md router handles an explicitly invoked itqan request, selecting an individual skill or delegating the full lifecycle to engineer. define turns an unclear request into a specification or PRD and owns schema and API-contract design; blueprint creates a dependency-ordered, risk-first task plan; construct builds against the repository's established patterns using TDD and mutates the implementation to confirm that a new test can fail; verify reruns tests, reads their output and count, and seeks root causes before fixes; inspect conducts a read-only five-axis review in an isolated or fresh-eyes context; release prepares rollback-first rollout steps, a runbook, and a GO/NO-GO decision. When applicable, discover conducts cited market and usage research, design handles web and mobile UI/UX work, harden produces a threat model and OWASP audit, assess creates a five-expert application health report, and learn develops personalized learning or codebase-onboarding plans. It records operating context, standards, decisions, task indexes, change entries, artifacts, approvals, and validation state under engineering/, including a state.json ledger for each task.

  1. A development team with a feature request but no agreed implementation approach can run engineer to obtain a specification and risk-ordered plan before authorizing code.
  2. An engineer maintaining an established service can invoke construct alone to implement a well-defined change with tests that follow the repository's existing patterns.
  3. A senior developer preparing a consequential merge can use verify to rerun and inspect test evidence, then inspect for an independent review that does not edit the code.
  4. A team changing authentication, PII, or payment paths can run harden for threat modeling and an OWASP audit, with unresolved Critical findings blocking release.
  5. A release owner who needs staged deployment and a documented rollback path can use release to separate merge readiness from deployment safety and receive a GO/NO-GO verdict.
  6. A distributed team handling work across sessions, machines, or people can resume from the engineering/ workspace, revalidate completed steps, and continue at the first unproven item.

What are this agent's strengths and limitations?

Pros
  • Two distinct human approval gates precede implementation, and resumed runs check that approvals were recorded; a rejection requires revision against the stated reason.
  • Verification requires current test execution, inspection of output, and validation of the collected-test count; collecting zero tests is treated as a discovery failure.
  • The 12 skills are pure Markdown and the root router is documented for more than 70 agents, including Codex, Cursor, Claude Code, Gemini CLI, Windsurf, Zed, and Hermes.
  • The persistent engineering/ workspace preserves decisions, specifications, plans, reviews, and a task ledger across sessions, machines, and handoffs.
  • Authentication, PII, and payment work triggers a harden pass, and any open Critical finding blocks shipping.
Limitations
  • The project is still at version 0.x, and its conventions may change between releases.
  • The documented experiment found no improvement in judging whether code was well shaped, so its review should be treated as a floor rather than a substitute for a skilled human reader.
  • The approval ledger records that someone approved an artifact, not that they actually read it.
  • Runtime guarantees vary: Claude Code enforces disabled model invocation and isolated review context, while other runtimes may rely on conventions or a fresh-eyes fallback.
  • Adoption adds a persistent engineering/ artifact structure and asks the team to follow its approvals, evidence rules, and resume procedure.

How do you install or deploy this agent?

The recommended path requires Node.js 22.20 or newer:

npx skills add saleh-alhaddad/itqan-engineering

A guided installer is also documented:

curl -fsSL https://raw.githubusercontent.com/saleh-alhaddad/itqan-engineering/main/install.sh | bash

For Claude Code, run:

/plugin marketplace add saleh-alhaddad/itqan-engineering
/plugin install itqan

To target another supported agent explicitly, run:

npx skills add saleh-alhaddad/itqan-engineering -a <agent>

Other runtimes can point their skill loader at the repository's root SKILL.md. The repository does not ship an itqan shell executable: these commands install the Markdown skills, which are then invoked inside the AI tool.

How do you use this agent?

After an npx, guided-installer, or Cursor installation, explicitly name the skill inside the AI tool:

itqan "add password reset to the auth service"

On the first run it scans the repository, asks targeted questions with suggested answers, and asks where the engineering/ workspace should live and who should see it. It then presents a specification for approval, presents a plan for approval, builds test-first, verifies the result, reviews it, and reaches a GO/NO-GO release decision. To resume later, use:

itqan "continue"

The Claude Code plugin registers all 12 skills separately, for example:

itqan:engineer "add password reset to the auth service"
itqan:inspect "review this change"

On another compatible runtime, explicitly ask it to “use the itqan skill to …”. The skills never self-trigger, and itqan is not a system-shell command.

FAQ

Will it start changing code automatically?
No. Every skill declares disable-model-invocation: true and must be explicitly named. The full flow also waits for specification and plan approval before implementation.
Can it commit or push changes on my behalf?
Not without user authorization. It prepares a per-file summary, risks, and a suggested commit message, then waits.
What happens when a task is interrupted?
Invoke itqan "continue". It reads the ledger under engineering/, reruns tests and checks completed work, then resumes at the first step that lacks current evidence.
When can security findings stop a release?
Authentication, PII, and payment work requires a harden pass, and any unresolved Critical finding blocks the release decision.
Does it require a paid service or API key?
The supplied material names no paid service or required API credential. It does require a compatible AI runtime that can load the Markdown skills and access the repository; the npx installation path additionally requires Node.js 22.20 or newer.

Compare agents like this one

The same FARS review applied across the shortlist this agent qualifies for.

Related agents