Skip to content
AI Marketplaces Leaderboard

Headcount: Technology

ChatGPT plugin

Your technology department

View in ChatGPT directory

Plan software projects, review architecture and APIs, debug failures, and improve engineering workflows. Headcount Technology includes nineteen reusable skills covering implementation planning, code review, testing, development practices, and AI automation design. Use it to turn requirements into an actionable plan or identify what evidence to collect when a system fails. Works with information you provide and tools available in ChatGPT. Part of the Headcount department skill collection, created by Chris Brock.

Featured
No

not on the featured shelf

Movement

From our daily snapshots over the last 30 days.

Rank by placement

#8738of 8,79371places down24h—7d
#8,500#8,566#8,632#8,698Sep 27Oct 3Oct 9Oct 15Oct 21Oct 26

Rank in Productivity

#2138of 2,14613places down24h—7d
#2,075#2,093#2,111#2,129Sep 27Oct 3Oct 9Oct 15Oct 21Oct 26

In its category

How this plugin compares with others in the same category. Positions are counted within the category, not across the whole directory.

Productivity2,138th of 2,146 by placement
#PluginPosition7d
2136SCORM Kit#8735—
2137Headcount: Executive#8737—
2138Headcount: TechnologyThis page#8738—
2139Token Saver#8744—
2140Support informatique guidé#8749—

All 2,146 Productivity plugins

More from Chris Brock

All listings by Chris Brock

Example prompts

  • “Review this architecture proposal and explain its risks and alternatives.”
  • “Turn these requirements into a practical implementation plan.”
  • “Help me debug this failure and decide what evidence to collect next.”

Skills

  • ai-workflow-architect

    Designs AI systems, automations, and agent workflows for a business — identifying which manual work is worth automating, how to structure the system, which tools fit, and what could go wrong. Use this to automate part of an operation, design an agent or MCP workflow, reduce repetitive manual work, connect tools into a system, decide which automation to build first, or audit an automation that is not delivering.

  • api-design

    Designs interfaces that survive their consumers — resource modeling, errors, versioning, pagination, and compatibility. Use this to design a new API, review one before it ships, decide how to version or deprecate, fix an interface consumers keep misusing, or work out whether a change is breaking.

  • branch-and-worktree-workflow

    Isolates feature work in its own branch or worktree and integrates it cleanly when done. Use this when starting work that should not disturb the current workspace, when several efforts must proceed in parallel on one repository, or when implementation is finished and the change needs merging, rebasing, or splitting for review.

  • chief-technology-officer

    Owns architecture, engineering delivery, infrastructure, data platform, and internal systems. Use this for build-versus-buy calls, technology selection, architectural direction, engineering capacity and delivery risk, technical debt tradeoffs, platform and tooling decisions, or when a technical choice has business consequences that need stating in business terms. Also use to judge whether a technical plan is sound before it is committed to.

  • cloud-infrastructure

    Designs and runs cloud infrastructure — environments, infrastructure as code, networking and isolation, scaling, and cost. Use this to design a cloud environment, control infrastructure spend, set up environment separation, plan for scale or region failure, or review infrastructure someone configured by hand.

  • code-review

    Conducts and responds to code review — reviewing a change for correctness, design, and risk, and evaluating review feedback received on your own work. Use this before merging, when asked to review a diff or pull request, when review feedback has arrived and needs acting on, or when feedback seems wrong and needs a reasoned response rather than compliance.

  • completion-verification

    Verifies that work is actually complete before it is claimed to be — running the checks, reading the output, and confirming the original request was satisfied rather than approximated. Use this before saying something is done, fixed, or passing; before committing or opening a pull request; and whenever a claim of success has not been backed by command output.

  • data-migration

    Moves data from one system to another without losing it or corrupting it — profiling the source before mapping, deciding between big-bang and parallel-run cutover, reconciling counts and values rather than assuming, handling the records that will not map cleanly, and planning a rollback that is actually executable. Use this to plan or run a migration, assess a migration plan someone else wrote, work out why a completed migration is producing wrong numbers, or size how long one will really take.

  • implementation-planning

    Turns a spec or requirement into a written plan a separate session or agent can execute, then drives that plan through review checkpoints. Use this before touching code on any multi-step task, when work needs handing to someone else, when a task keeps sprawling mid-implementation, or when a plan exists and needs executing in order with verification between steps.

  • observability-and-reliability

    Makes systems debuggable and reliably operable — instrumentation, alerting that is worth waking for, service objectives, and learning from failure. Use this to instrument a service, fix alerting that is ignored, set error budgets or reliability targets, prepare for on-call, or run a blameless post-incident review.

  • parallel-agent-delivery

    Splits work across multiple agents or sessions running at once, keeping their surfaces disjoint so results merge cleanly. Use this when facing several independent tasks with no shared state, when a plan has parallelizable steps, when a broad search or audit would be faster fanned out, or when deciding whether work can safely be split at all.

  • prompt-optimizer

    Turns rough intent or a weak prompt into a reliable one — diagnosing why output is inconsistent, restructuring the instruction, and adapting it across models. Use this when a prompt is not producing what was wanted, when output varies run to run, when writing a prompt for a repeated task, when moving a prompt between models, or when someone describes what they want an AI to do and needs it written properly.

Show all 19
  • release-and-deployment

    Ships changes safely and often — pipelines, deployment strategies, feature flags, rollback, and database changes. Use this to design a deployment pipeline, reduce release risk, roll out a risky change gradually, plan a schema migration, or work out why releases are infrequent and frightening.

  • skill-authoring

    Writes and revises agent skills so they trigger at the right moments and give usable instruction when they do. Use this when creating a new skill, editing an existing one, diagnosing a skill that fires too often or never fires, or reviewing a set of skills for overlap. Also use before adding to a skill library, to check the capability is not already covered.

  • solution-architecture

    Designs system structure and makes architectural decisions defensible — boundaries, coupling, trade-offs, and recording why. Use this to design a new system or major component, choose between architectural options, review an existing design, decide where a boundary belongs, or document an architectural decision so it survives the people who made it.

  • solution-exploration

    Explores the problem and the range of possible approaches before any code is written — clarifying what is actually being asked, surfacing options with their tradeoffs, and converging on one. Use this at the start of any feature, component, or behavior change, when a request is ambiguous, when the first idea is the only idea on the table, or when a design decision needs pressure-testing before commitment.

  • systematic-debugging

    Finds the root cause of a bug, test failure, or unexpected behavior before proposing any fix. Use this whenever something is broken and the cause is not yet proven — a failing test, a production error, intermittent behavior, or a symptom that appeared after a change. Also use when a fix has been attempted and did not work, or when the same bug keeps coming back.

  • technical-debt-management

    Makes technical debt visible and decidable — distinguishing real debt from mess, quantifying its cost, and arguing for remediation in business terms. Use this to assess and prioritize debt, decide whether to fix or live with something, justify remediation work to non-engineers, or plan a migration off a system nobody wants to touch.

  • test-driven-development

    Drives implementation by writing a failing test first, then the smallest code that passes it. Use this before writing implementation code for any feature or bugfix, when a bug needs a regression test, when existing code is hard to change safely, or when someone asks whether a change is covered. Also use to decide what is worth testing and what is not.

Categories
Made by
Chris Brock · Website
Sign-in
On Install
Availability
Available
Version
1.0.1
Created
October 9, 2026
More info
Sponsorship
Promote this plugin