agentsclimarketplace
Sign in

Prioritize architecture aware

Skill alexe-ev/product-plugins/technical-product/skills/prioritize-architecture-aware

Incorporate architectural constraints and technical debt into product prioritization decisions. Use this skill when a team needs to balance feature work with technical investment.From its SKILL.md

Install
npx -y skills add alexe-ev/product-plugins --skill prioritize-architecture-aware

Assembled from the repository path, not quoted from the project. Check it against their README if it does not work.

One thing to look at

  • 0 stars0 stars. Stars are a popularity signal and not a quality one, but at this level it is likely that nobody has read this closely except its author, and you would be relying on your own review.

SKILL.md

2.5 KB, 437 tokens by cl100k_base, as published. Nobody here has run it

Prioritize Architecture-Aware

Purpose

Help product teams make prioritization decisions that account for architectural constraints, technical debt, and engineering feasibility — not just user value.

Skill type

Conceptual skill

Use this skill when

  • Technical debt is blocking feature development speed
  • Engineering is requesting investment in infrastructure but product can't evaluate it
  • A prioritization decision requires architectural context
  • A team is planning a major technical migration alongside feature work

Do not use this skill when

  • The goal is pure feature prioritization without technical constraints (use build-roadmap-prioritization)
  • The goal is a technical architecture decision (engineering-owned)

Required inputs

  • Feature or initiative backlog (even rough)
  • Technical debt or architecture constraints (as described by engineering)
  • Business goals

Optional inputs

  • Engineering capacity breakdown (feature vs. infrastructure)
  • Current system limitations
  • Migration or upgrade plans

Upstream context

Works best when:

  • Roadmap priorities are defined
  • Engineering has flagged technical constraints

Downstream handoff

Output can feed:

  • plan-delivery-collaboration (architecture-aware plan feeds delivery)
  • collaborate-with-engineering

Instructions

  1. Identify technical constraints and their product impact (velocity reduction, user impact, reliability risk).
  2. Translate technical debt into product terms: what does it cost in delivery speed or quality?
  3. Assess the trade-off: feature investment vs. technical investment.
  4. Recommend a ratio and sequencing for technical vs. feature work.
  5. Identify technical investments that unlock future feature velocity.
  6. Flag dependencies between technical and feature work.

Output

Provide:

  • Technical constraint summary in product terms
  • Trade-off assessment: features vs. technical investment
  • Recommended investment ratio and rationale
  • Sequencing recommendation
  • Dependencies between technical and feature work
  • Assumptions from engineering that need validation

Risks / caveats

  • Product decisions that ignore technical debt create compounding delivery problems
  • Always validate technical assessments with engineering — don't assume
  • Technical investment without a product value narrative is hard to prioritize — frame both sides

What ships with it: 4 files

7.8 KB alongside SKILL.md

examples/

Gives 0 of the 12 instructions most architecture codebase skills give in 437 tokens

Counted across 811 of the 1,134 authors here whose files we hold, read 2026-08-07

  • Ask the user which candidate to explorein 45 of 811, across 15 files
  • Apply the deletion test to suspected shallow modulesin 43 of 811, across 15 files
  • Read any relevant architecture decision records firstin 31 of 811, across 8 files
  • Use exact glossary terms in every suggestionin 30 of 811, across 10 files
  • Accept dependencies instead of creating themin 24 of 811, across 5 files
  • Include before and after visualisations for each candidatein 24 of 811, across 5 files
  • Read the domain glossary before exploringin 24 of 811, across 6 files
  • Return results instead of producing side effectsin 23 of 811, across 4 files
  • Explore the codebase for shallow modules and frictionin 23 of 811, across 3 files
  • Introduce seams only where things varyin 22 of 811, across 3 files
  • Reduce the number of methodsin 21 of 811, across 2 files
  • Design deep modules with small interfacesin 21 of 811, across 3 files

Said here and by no other author read

  • Identify technical constraints and their product impact
  • Translate technical debt into product terms
  • Assess the trade-off between feature and technical investment
  • Recommend a ratio for technical versus feature work
  • Sequence technical and feature work
  • Identify investments unlocking future feature velocity

Grouped from the skills themselves: near-identical wordings counted once, and counted by distinct author, so one author publishing three of these counts once. Length counted with cl100k_base; the agent that loads this file may tokenize it differently.

Keep looking

Skills are one crate of 326,696. Ordering is by how many stacks a row turns up in, so the top of any crate is what has actually been picked rather than what has the most stars.