ape-write-pseudocode — independently scanned and version-tracked by SaferSkills.
SaferSkills independently audited ape-write-pseudocode (Agent Skill) and scored it 100/100 (green). The audit ran 55 deterministic rules across Security, Supply Chain, Maintenance, Transparency, and Community; it found 0 high-severity and 0 lower-severity findings. The full rule-by-rule trace and per-finding evidence are below. Free, methodology-open.
Findings & checks · 0 flagged
Every scanned point with the score it earned and what moved between them.
First recorded scan — no prior version to compare against.
The primary manifest — the file an agent reads to learn what this artifact does.
Every pseudocode function has exactly three parts: input, output, and body. Use Python-like syntax: def for the function signature, a docstring-style comment block for input and output, and indented body lines.
def function_name(param1, param2, ...):
# input: <what each param represents>
# output: <what the function returns or produces>
<body>The body is the core of the pseudocode. Each line describes one logical step at a very high level -- what the step takes as input and what it produces as output. Do not write code. Do not spell out implementation details.
Use if, elif, else, and loops sparingly and only when the branching or iteration is the point of the logic. Use Python-like keywords and colon-terminated headers.
if <condition>:
<what happens>
else:
<what happens instead>
for each <item> in <collection>:
<what is done with item>
while <condition>:
<what is repeated>Keep conditions at the same high level as the rest of the body -- describe the condition in plain words, not code.
Each line should answer: "given what input, produce or decide what output?"
Good patterns:
filter nodes by reachability from sourcesort entries by timestamp, oldest firstcompute shortest path from source to each nodepick the candidate with the highest scoremerge left result and right result into sorted listBad patterns (too much detail):
dist[v] = dist[u] + weight(u, v) -- this is codeinitialize a min-heap priority queue with (0, source) -- implementation detaillist.stream().filter(x -> x > 0).collect(...) -- this is definitely codeGood:
def lsm_write(key, value):
# input: key and value to store
# output: acknowledgement that write is recorded
append key-value pair to memtable
if memtable exceeds size threshold:
flush memtable to a new SSTable on disk
clear memtabledef lsm_read(key):
# input: key to look up
# output: value for key, or not found
check memtable for key
if found in memtable:
return value from memtable
for each SSTable from newest to oldest:
check bloom filter for key
if bloom filter says key may exist:
search SSTable for key
if found:
return value
return not founddef lsm_compact(sstables):
# input: list of SSTables to merge
# output: single merged SSTable with duplicates resolved
open a cursor on each SSTable
while any cursor has remaining entries:
pick the entry with the smallest key across all cursors
if same key appears in multiple SSTables:
keep only the entry from the newest SSTable
write chosen entry to output SSTable
return output SSTableBad (do not do this):
def lsm_write(key: str, value: bytes): # typed signature -- not pseudocode
self.lock.acquire()
self.memtable[key] = value # this is Python code, not pseudocode
if len(self.memtable) > self.threshold:
self.flush()
self.lock.release()If yes, the pseudocode is done.
~30 seconds. Free. No account. Every finding cites a rule and a line of evidence.