SkillAgentSearch skills...

map-optimization-strategy

Strategy for solving constraint optimization problems on spatial maps

Install / Use

npx skills add benchflow-ai/skillsbench --skill map-optimization-strategy

Installs into whichever agent you are using.

About this skill
📄

SKILL.md

Installable skill definition

Quality Score

80/100

Supported Platforms

Universal

Tags

Our assessment of map-optimization-strategy

map-optimization-strategy scores 80/100 on our quality scale, 3600th of 4,698 Development & Engineering skills we index.

Its SKILL.md is 4.3 KB long, well organised into 9 sections with 3 code examples: a solid amount of guidance for an agent.

With 1,813 GitHub stars, it is one of the more widely adopted skills in the catalogue.

Substance
26/30
Structure
18/20
Description
12/15
Adoption
14/20
Freshness
11/15

Maintenance, license and trust

  • The repository was last updated about 4 months ago. That is recent enough to be usable, but agent tooling moves fast, so check the instructions against your agent's current version.
  • Our last check on 2026-11-08 found the source still online.
  • It is released under the Apache-2.0 license, a permissive license that allows use, modification and commercial use with attribution.
  • Its trust signals score 98/100, with no cautions. These come from repository metadata, not a code audit — read the skill file before letting an agent act on it.

Safety scan

No issues found

Our scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful.

AI review by kimi-k2.7-code on 2026-10-01. Automated pattern scan on 2026-10-01. It catches known dangerous patterns, not every risk — read a skill before letting an agent act on it.

map-optimization-strategy compared with similar skills

All 4 of these similar skills score higher than map-optimization-strategy; compare them before choosing.

SkillScoreStarsUpdatedFormat
map-optimization-strategy (this skill)by benchflow-ai801.8k4mo agoSKILL.md
taste-skillby Leonxlnx100116.8k8d agoCLAUDE.md
ai-job-searchby ai-job-search-dev10072.1ktodayCLAUDE.md
claude-howtoby luongnv8910047.3k2d agoCLAUDE.md
lobehubby lobehub10085.6ktodayMCP Server

Frequently asked questions

How do I install map-optimization-strategy?
Run npx skills add benchflow-ai/skillsbench --skill map-optimization-strategy. The install tabs above show the steps for each supported agent.
Which AI agents does map-optimization-strategy work with?
It is written for Universal, as a SKILL.md file. Other agents that read the same format can often use it too.
Is map-optimization-strategy safe to use?
Our scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful. It is Apache-2.0-licensed and scores 98/100 on trust signals. Skills are instructions an agent will follow, so read the file before installing it and do not approve commands you do not understand.
Is map-optimization-strategy still maintained?
The repository was last updated about 4 months ago. That is recent enough to be usable, but agent tooling moves fast, so check the instructions against your agent's current version.

name: map-optimization-strategy description: Strategy for solving constraint optimization problems on spatial maps. Use when you need to place items on a grid/map to maximize some objective while satisfying constraints.

Map-Based Constraint Optimization Strategy

A systematic approach to solving placement optimization problems on spatial maps. This applies to any problem where you must place items on a grid to maximize an objective while respecting placement constraints.

Why Exhaustive Search Fails

Exhaustive search (brute-force enumeration of all possible placements) is the worst approach:

  • Combinatorial explosion: Placing N items on M valid tiles = O(M^N) combinations
  • Even small maps become intractable (e.g., 50 tiles, 5 items = 312 million combinations)
  • Most combinations are clearly suboptimal or invalid

The Three-Phase Strategy

Phase 1: Prune the Search Space

Goal: Eliminate tiles that cannot contribute to a good solution.

Remove tiles that are:

  1. Invalid for any placement - Violate hard constraints (wrong terrain, out of range, blocked)
  2. Dominated - Another tile is strictly better in all respects
  3. Isolated - Too far from other valid tiles to form useful clusters
Before: 100 tiles in consideration
After pruning: 20-30 candidate tiles

This alone can reduce search space by 70-90%.

Phase 2: Identify High-Value Spots

Goal: Find tiles that offer exceptional value for your objective.

Score each remaining tile by:

  1. Intrinsic value - What does this tile contribute on its own?
  2. Adjacency potential - What bonuses from neighboring tiles?
  3. Cluster potential - Can this tile anchor a high-value group?

Rank tiles and identify the top candidates. These are your priority tiles - any good solution likely includes several of them.

Example scoring:
- Tile A: +4 base, +3 adjacency potential = 7 points (HIGH)
- Tile B: +1 base, +1 adjacency potential = 2 points (LOW)

Phase 3: Anchor Point Search

Goal: Find placements that capture as many high-value spots as possible.

  1. Select anchor candidates - Tiles that enable access to multiple high-value spots
  2. Expand from anchors - Greedily add placements that maximize marginal value
  3. Validate constraints - Ensure all placements satisfy requirements
  4. Local search - Try swapping/moving placements to improve the solution

For problems with a "center" constraint (e.g., all placements within range of a central point):

  • The anchor IS the center - try different center positions
  • For each center, the reachable high-value tiles are fixed
  • Optimize placement within each center's reach

Algorithm Skeleton

def optimize_placements(map_tiles, constraints, num_placements):
    # Phase 1: Prune
    candidates = [t for t in map_tiles if is_valid_tile(t, constraints)]

    # Phase 2: Score and rank
    scored = [(tile, score_tile(tile, candidates)) for tile in candidates]
    scored.sort(key=lambda x: -x[1])  # Descending by score
    high_value = scored[:top_k]

    # Phase 3: Anchor search
    best_solution = None
    best_score = 0

    for anchor in get_anchor_candidates(high_value, constraints):
        solution = greedy_expand(anchor, candidates, num_placements, constraints)
        solution = local_search(solution, candidates, constraints)

        if solution.score > best_score:
            best_solution = solution
            best_score = solution.score

    return best_solution

Key Insights

  1. Prune early, prune aggressively - Every tile removed saves exponential work later

  2. High-value tiles cluster - Good placements tend to be near other good placements (adjacency bonuses compound)

  3. Anchors constrain the search - Once you fix an anchor, many other decisions follow logically

  4. Greedy + local search is often sufficient - You don't need the global optimum; a good local optimum found quickly beats a perfect solution found slowly

  5. Constraint propagation - When you place one item, update what's valid for remaining items immediately

Common Pitfalls

  • Ignoring interactions - Placing item A may change the value of placing item B (adjacency effects, mutual exclusion)
  • Over-optimizing one metric - Balance intrinsic value with flexibility for remaining placements
  • Forgetting to validate - Always verify final solution satisfies ALL constraints

Related Skills

View on GitHub
GitHub Stars1.8k
CategoryDevelopment
Updated3mo ago
Forks368

Languages

PDDL

Trust signals

98/100

From repository metadata: license, adoption, age and documentation. Not a code audit — see the Safety scan above for what the skill file itself contains.

1 info