Justis📍 Northwest Houston
The problem: the drive became corrupted, and the computer couldn't get to the files on it.
The fix: I recovered the data and handed the files back safe.
✓ Data recoveredYou run the business. I run the tech.
Same-day repair for any computer within 50 miles of Houston. Custom software and AI workflow tools for businesses of any size, anywhere in the world. 30 years of computer experience, including 10 years experience in blockchain and AI.
Services start at $59 · Free assessment and quote
Check your area · Ask a quick question free
Recent jobs for people right here in the Houston area.
The problem: the drive became corrupted, and the computer couldn't get to the files on it.
The fix: I recovered the data and handed the files back safe.
✓ Data recoveredThe problem: a corrupted, failing hard drive, and the computer couldn't get to the files on it.
The fix: I recovered the data, replaced the failing drive, and handed back a working computer with the files on it.
✓ Drive replaced · data recoveredThe job: a network that needed to be installed and Wi-Fi that needed to work properly.
The fix: I installed the network and set up the Wi-Fi from start to finish, so everything connects without Jerry having to think about it.
✓ Network installed · Wi-Fi set upMost people expect to choose between fast and careful. Experience means I recognize most problems quickly, and my process checks every piece of work, so you get both.
Most repairs are diagnosed, priced and fixed the day you reach out, then tested in front of you.
You see a working preview early and watch it grow, instead of waiting months for a big reveal.
Automated checks run on every change before you ever see it, so speed never means sloppy.
Three decades of building, fixing and programming computers, from home PCs to a 6,000 sq ft GPU facility.
A decade working in new technology like blockchain and AI, so your project uses what works today, not last decade's tools.
No account managers or queues between teams. The person you talk to is the person doing the work.
Proof: this website, its lead system and its private sales dashboard were designed, built and tested in under 2 hours of build time.
Press ▶ Start live demo to run a project right inside its card, or open </> Code to read real lines from the project's own files.
23 projects · 22 you can open live · 18 with real code you can read
A blockchain network where mining trains an AI model. Includes a wallet, a block explorer and a mining dashboard.
/* the log has to be a real training line before any index into it
means anything — a repeated step number would make the recompute
below run ZERO steps and match trivially (library.checkSteplog) */
const sl = L.checkSteplog(entries);
if (!sl.ok) return rej('', sl.reason, 0);
const e = entries[idx], nx = entries[idx + 1];
/* ── GATE 1 · the arithmetic, bit for bit ────────────────────────── */
const snap = await fetchArtifact(e.snapRoot);
if (!snap) return rej(e.wHash, 'missing-snapshot', e.step);
let got;
try { got = T.regionHash(snap); } catch (_) { return rej(e.wHash, 'unreadable-snapshot', e.step); }
if (got !== e.wHash) return rej(e.wHash, got, e.step); /* snapshot lies about itself */
const model = T.loadWeights(snap);
T.trainSegment(model, shard.text, leaseSeed, e.step, nx.step - e.step);
const got2 = T.weightsHash(model);
if (got2 !== nx.wHash) {
/* ── O4 · "gpu makes the model cpu validates" ───────────────────────
A CPU commit is held to the bit-for-bit recompute, exactly as before:
a difference is provable fraud and REJECT stands. Where the chain
records maker.kind = 'gpu', the question is the MEASURED one instead:
the device's own bytes for the end of this segment, scored against
the CPU's recompute of the same segment, within the measured
tolerance. Outside it this REFUSES — no merge and NO slash, because a
device that rounds differently is not a fraudster (and
CONST.GPU_REJECT_BOUND is null). The snapshot still has to be honest
about itself: a lie about its own hash is a REJECT on either path. */
const maker = opts.maker || null;
if (!maker || maker.kind !== 'gpu') return rej(nx.wHash, got2, e.step);Validators redo a slice of the miner's AI training themselves; if the result differs by a single bit, the miner is caught and penalised.
22 free, comic-style coding adventures that teach programming step by step, with progress and XP.
A free AI art hub: generate art, edit it in a Photoshop-style browser editor, and sell it with creator-friendly splits.
A free browser arcade of hand-built comic and anime games, plus head-to-head chess, checkers and spades.
/* is (x,y) inside another worm's body (with padding)? */
hitAt(x, y, self, pad) {
for (const w of this.worms) {
if (w === self || w.dead) continue;
const r = this.rad(w) + pad;
for (let i = 0; i < w.segs.length; i += 2) if (dist2(x, y, w.segs[i].x, w.segs[i].y) < r * r) return true;
}
return x < pad + 20 || y < pad + 20 || x > this.WORLD - pad - 20 || y > this.WORLD - pad - 20;
},
brain(w, dt) {
w.think -= dt; if (w.think > 0) return; w.think = 0.12 + Math.random() * 0.08;
const h = w.segs[0], r = this.rad(w);
/* feelers: straight, left, right — swerve away from bodies and the wall */
const look = 30 + r * 3, fe = [0, -0.6, 0.6].map(o => {
const an = w.ang + o; return this.hitAt(h.x + Math.cos(an) * look, h.y + Math.sin(an) * look, w, r + 4);
});
if (fe[0] || fe[1] || fe[2]) {
w.ta = w.ang + (fe[1] && !fe[2] ? 1.3 : !fe[1] && fe[2] ? -1.3 : (Math.random() < .5 ? 1.6 : -1.6));
w.boost = false; return;
}
const me = this.me, mh = me.segs[0];
const aggro = Math.min(0.85, 0.15 + this.t / 240) * (0.5 + w.agg);
const dm = dist2(h.x, h.y, mh.x, mh.y);
if (!me.dead && dm < 260 * 260 && w.len > 18 && Math.random() < aggro) {
/* try to cut across the player's nose */
const tx = mh.x + Math.cos(me.ang) * (70 + r * 3), ty = mh.y + Math.sin(me.ang) * (70 + r * 3);
w.ta = Math.atan2(ty - h.y, tx - h.x); w.boost = w.len > 30 && Math.random() < 0.5; return;
}
w.boost = false;
let best = null, bd = 300 * 300;
for (const o of this.orbs) {
const d = dist2(h.x, h.y, o.x, o.y) / (o.v > 1 ? 3 : 1);
if (d < bd) { bd = d; best = o; }
}
if (best) w.ta = Math.atan2(best.y - h.y, best.x - h.x);
else w.ta = w.ang + rand(-0.6, 0.6);
},Computer rivals feel ahead for walls and bodies, try to cut the player off as rounds go on, and otherwise hunt the best food.
1,000 AI prompts and 24 classes that teach people how to get real results from AI tools.
A confidential business-valuation assessment for owners, with a secure advisor console.
A complete operating system in the browser: windows, desktop, files, a built-in AI assistant and apps.
/* Only the last 500 blocks are kept, so the chain cannot verify back to the
zero hash forever. The ANCHOR is what makes pruning honest: when blocks are
dropped, the hash and number of the last dropped block are kept, and the
check starts there instead of at zero. Without it, the 501st block made
every later check report "prev-hash mismatch" — an instance that had done
nothing wrong was told its history had been tampered with, permanently. */
var KEEP = 500;
function anchorKey(id) { return 'l8os:chainbase:' + id; }
function readAnchor(id) { try { return JSON.parse(localStorage.getItem(anchorKey(id)) || 'null'); } catch (e) { return null; } }
function readChain(id) { try { return JSON.parse(localStorage.getItem(chainKey(id)) || '[]'); } catch (e) { return []; } }
function writeChain(id, c) {
try {
if (c.length > KEEP) {
var last = c[c.length - KEEP - 1]; // the newest block about to be dropped
localStorage.setItem(anchorKey(id), JSON.stringify({ n: last.n, hash: last.hash }));
}
localStorage.setItem(chainKey(id), JSON.stringify(c.slice(-KEEP)));
} catch (e) {}
}
function appendBlock(id, extra) {
var c = readChain(id), a = readAnchor(id);
var prev = c.length ? c[c.length - 1].hash : (a ? a.hash : ZERO);
/* numbering counts the pruned blocks too, so block numbers never repeat */
var n = (a ? a.n + 1 : 0) + c.length;
var body = Object.assign({ n: n, ts: Date.now(), prev: prev, instance: id.slice(0, 16) }, extra || {});
var block = Object.assign({}, body, { hash: '0x' + sha256hex(JSON.stringify(body)) });
c.push(block); writeChain(id, c); return block;
}
function verifyChain(id) {
var c = readChain(id), a = readAnchor(id), prev = a ? a.hash : ZERO;
for (var i = 0; i < c.length; i++) {
var b = c[i], body = {}; for (var k in b) if (k !== 'hash' && k !== 'sealed') body[k] = b[k];
if (b.prev !== prev) return { ok: false, at: i, why: 'prev-hash mismatch' };
if (b.hash !== '0x' + sha256hex(JSON.stringify(body))) return { ok: false, at: i, why: 'block hash mismatch' };
prev = b.hash;
}
/* `pruned` is reported so nobody reads "ok" as "every block since genesis
was checked" — the dropped ones are gone and cannot be re-checked. */
return { ok: true, blocks: c.length, pruned: a ? a.n + 1 : 0, from: a ? a.n + 1 : 0 };
}Every boot adds a block linked to the one before, so a corrupted past record is detected, and trimming old blocks never raises a false alarm.
A small transformer language model written in plain JavaScript: training, gradients and tokenizer, checked layer by layer.
/* The model is Float32 by design, and a numerical gradient divides a
difference of two f32 losses by 2h. Error accumulated across the whole
forward pass lands around 1e-3 in absolute terms, so a gradient whose
true value is 3e-4 can come back with the wrong SIGN and a relative
error of 1.0 while the implementation is perfectly correct.
Judging such an entry by relative error alone is measuring float
rounding, not the derivative. So an entry passes if EITHER the
relative error is small OR the absolute disagreement is below that
noise floor — and the floor is stated rather than tuned until green. */
const NOISE = 2e-3;
for (const [name, p] of named) {
let maxRel = 0, maxAbs = 0, sampleN = Math.min(12, p.n);
for (let k = 0; k < sampleN; k++) {
const i = Math.floor(pick() * p.n);
const orig = p.v[i];
p.v[i] = orig + H; const lp = lossAt();
p.v[i] = orig - H; const lm = lossAt();
p.v[i] = orig;
const num = (lp - lm) / (2 * H);
const ana = p.g[i];
const abs = Math.abs(num - ana);
if (abs < NOISE) { checked++; if (abs > maxAbs) maxAbs = abs; continue; }
const rel = abs / Math.max(1e-9, Math.abs(num) + Math.abs(ana));
if (rel > maxRel) maxRel = rel;
if (abs > maxAbs) maxAbs = abs;
checked++;
}
const ok = maxRel < 2e-2;
if (!ok) fails++;
if (maxRel > worst) { worst = maxRel; worstName = name; }Before any training run is trusted, the hand-written learning math is tested weight by weight against a brute-force measurement.
An everyday wallet plus a locked-away savings wallet, with safety checks built in.
function tronAddress(uncomp) {
const body = uncomp.slice(1); // drop 0x04
const addr = getBytes(keccak256(body)).slice(-20);
return base58check(cat(Uint8Array.of(0x41), addr));
}
// Algorand · base32(pubkey + sha512/256(pubkey)[-4:]) · no padding
const algoAddress = (pub) => base32.encode(cat(pub, sha512_256(pub).slice(-4))).replace(/=+$/, '');
// SS58 · base58(prefix || pubkey || blake2b512("SS58PRE"||...)[:2])
function ss58(prefix, pub) {
const data = cat(Uint8Array.of(prefix), pub); // prefix < 64 → single byte
const cs = blake2b(cat(utf8('SS58PRE'), data), { dkLen: 64 }).slice(0, 2);
return base58.encode(cat(data, cs));
}
/* ── SLIP-0010 · ed25519 (hardened-only) ───────────────────────────── */
function ser32(i) { const b = new Uint8Array(4); new DataView(b.buffer).setUint32(0, i >>> 0, false); return b; }
function slip10Ed25519(seedBytes, path) {
let I = hmac(sha512, utf8('ed25519 seed'), seedBytes);
let key = I.slice(0, 32), cc = I.slice(32);
for (const seg of path.replace(/^m\//, '').split('/').filter(Boolean)) {
const raw = seg.endsWith("'") ? seg.slice(0, -1) : seg;
const idx = (parseInt(raw, 10) | 0x80000000) >>> 0; // ed25519: all hardened
I = hmac(sha512, cc, cat(Uint8Array.of(0), key, ser32(idx)));
key = I.slice(0, 32); cc = I.slice(32);
}
return key;
}One recovery phrase produces correct addresses for Tron, Algorand, Polkadot and Solana-style chains, built on audited crypto libraries.
A perpetuals exchange: trade BTC, ETH and BNB long or short with leverage, with live prices and a liquidity pool.
/**
* Liquidation price: the boundary market price (1e8) at which liquidateCheck flips to true, found by
* exact integer binary search over the SAME function the contract runs (no closed-form approximation).
* Ignores the confirmTriggerPrice band (that depends on the cached price at execution time).
* Long: largest marketPrice with needLiq. Short: smallest marketPrice with needLiq. null if none in range.
* Assumes loss is monotonic in price on each side (true unless funding per share is ~1e18-scale).
*/
export function liquidationPrice({ ot, mt, pair, pairQty, longAcc, blockNumber, now, clock, slippageFormula }, hi = (1n << 64n) - 1n) {
const f = (mp) => {
try {
const cp = closePriceFor(ot, pairQty, pair.slippageConfig, mp, slippageFormula);
return liquidateCheck({ ot, mt, pair, marketPrice: mp, closePrice: cp, longAcc, blockNumber, now, clock }).needLiq;
} catch (e) { if (e instanceof SolidityRevert) return false; throw e; }
};
if (ot.isLong) {
let lo = 1n, top = B(ot.entryPrice) * 4n; if (top > hi) top = hi;
if (!f(lo)) return null;
if (f(top)) return top;
while (top - lo > 1n) { const mid = (lo + top) / 2n; if (f(mid)) lo = mid; else top = mid; }
return lo;
}
let lo = 1n, top = B(ot.entryPrice) * 100n; if (top > hi) top = hi;
if (!f(top)) return null;
if (f(lo)) return lo;
while (top - lo > 1n) { const mid = (lo + top) / 2n; if (f(mid)) top = mid; else lo = mid; }
return top;
}Finds the precise price where a leveraged position gets liquidated by running the same check the smart contract runs, with no estimates.
An honest token creator: it runs a 12-point safety audit on the token and only states what it actually checked.
/* ── pre-deploy audit · every check runs a real test on the source ───
Pattern checks run against the source with comments and string
literals STRIPPED: hidden logic can only live in code, and stripping
means a comment can neither trigger a false alarm nor talk its way
past a check. The name/symbol/supply checks use the full source. */
function stripComments(src) {
return src.replace(/\/\*[\s\S]*?\*\//g, '').replace(/\/\/[^\n]*/g, '').replace(/"(?:[^"\\]|\\.)*"/g, '""');
}
function preAudit(src, s) {
var code = stripComments(src);
var C = [];
function chk(label, pass, why, evidence) { C.push({ label: label, pass: pass, why: why, ev: evidence }); }
chk('Compiler version pinned', /pragma solidity 0\.8\.26;/.test(code),
'a floating pragma (^) lets a different compiler change the bytecode', 'pragma solidity 0.8.26;');
chk('No mint — supply is fixed forever', !/mint/i.test(code),
'the only supply assignment happens once, in the constructor', 'no “mint” in any code path');
chk('No owner, no admin, no Ownable', !/\bowner\b|onlyOwner|Ownable|renounce/i.test(code.replace(/event Approval\(address indexed owner/, '')),
'a contract with no privileged address has no one who can turn on you', 'no owner state or modifier exists');
chk('No pause, no trading switch', !/pause|enableTrading|tradingOpen|tradingActive/i.test(code),
'transfers cannot be frozen — not by you, not by anyone', 'no pause flag exists');
chk('No blacklist or whitelist', !/blacklist|whitelist|blocked|banned|bots\b/i.test(code),
'no address can be singled out and locked', 'no address-list state exists');
chk('No fees, taxes or reflections', !/fee|\btax|reflect|marketingWallet/i.test(code),
'a transfer moves exactly what you sent', 'transfer moves value, whole and untouched');
chk('No selfdestruct', !/selfdestruct/i.test(code), 'the contract cannot be removed from under its holders', 'absent');
chk('No delegatecall, no assembly, no external calls', !/delegatecall|assembly\s*{|\.call\(|\.call{|\.staticcall/i.test(code),
'nothing here executes foreign code or hides logic in bytecode', 'absent');
chk('Not upgradeable', !/proxy|upgrade|implementation\(\)/i.test(code),
'the code you read is the code it will run, forever', 'no proxy pattern');
chk('Supply literal equals your input', src.indexOf('totalSupply = ' + s.sup + ' * 10 ** 18') >= 0,
'what you typed is what is minted', s.sup + ' × 10¹⁸ base units');
chk('Name and symbol match your input',
src.indexOf('name = "' + s.name + '"') >= 0 && src.indexOf('symbol = "' + s.sym + '"') >= 0,
'no hidden rename', s.name + ' / ' + s.sym);
var fns = (code.match(/function\s+\w+/g) || []).map(function (m) { return m.replace(/function\s+/, ''); });
var expected = ['transfer', 'approve', 'transferFrom', '_transfer'];
chk('Exactly the ERC-20 surface — nothing extra', fns.length === 4 && expected.every(function (f) { return fns.indexOf(f) >= 0; }),
'four functions, all standard: ' + fns.join(', '), fns.join(' · '));
return C;
}Before a token launches, its code is checked for hidden minting, owners, fees, blacklists and upgrades, with comments stripped so nothing hides.
Turn the dials and watch an AI's mood engine react, with hormone-style signals, 47 moods and simulated medicine.
function classify(h) {
h = h || H;
if (h.cortisol > .68 && h.adrenaline > .58) return ['ALARMED','s-alarmed','#ff3850'];
if (h.prostaglandin > .55 && h.cortisol > .50) return ['INFLAMED','s-inflamed','#ff3850'];
if (h.coherency < .50) return ['DISCORDANT','s-discordant','#b48cff'];
if (h.coherency < .80) return ['TRANSITIONING','s-transitioning','#9d8cff'];
if (h.cortisol > .60) return ['STRESSED','s-stressed','#ff5a3a'];
if (h.glutamate > .62 && h.gaba < .40 && h.cortisol > .45) return ['AGITATED','s-agitated','#ffb000'];
if (h.resistin > .55 && h.thyroxine < .40) return ['STRAINED','s-strained','#ff7a3a'];
if (h.anp > .55 && h.cortisol > .45) return ['VENTING','s-venting','#ffb000'];
if (h.thyroxine > .62 && h.adrenaline > .50) return ['RAPID','s-rapid','#ffd34d'];
if (h.glucagon > .62 && h.insulin < .40) return ['SPENDING','s-spending','#ffb000'];
if (h.dopamine > .66 && h.adrenaline > .50) return ['HYPED','s-hyped','#ff5cf2'];
// BONDED sits above FLOW: the oxytocin+vasopressin quorum is a more specific
// condition than the zone, and being cared for should not be masked by it
if (h.oxytocin > .60 && h.vasopressin > .55 && h.cortisol < .50) return ['BONDED','s-bonded','#5c9bff'];
/* The two guards on FLOW are deliberate. Anandamide rises as cortisol falls,
so without `gaba < .55` a deeply-soothed organism reads as "the zone" while
its brake is fully engaged; and without `adrenaline < .55` a rousing pulse
reads as flow when it is plainly broad activation. Both were added here and
mirrored into MOLECULAR-PET so the family classifier stays one classifier. */
if (h.anandamide > .58 && h.norepinephrine > .50 && h.cortisol < .45
&& h.gaba < .55 && h.adrenaline < .55) return ['FLOW','s-flow','#00e5ff'];
if (h.glutamate > .60) return ['ACTIVATED','s-activated','#ffd34d'];
if (h.fgf21 > .58 && h.cortisol > .45 && h.cortisol < .62) return ['FORGED','s-forged','#ffb000'];
if (h.coherency > .93 && h.cortisol < .40 && h.gaba < .60) return ['SETTLED','s-settled','#ffd34d'];
if (h.insulin > .62 && h.serotonin > .55) return ['EFFICIENT','s-efficient','#2ee6a6'];
if (h.serotonin > .66 && h.endorphin > .55 && h.cortisol < .42) return ['ELATED','s-elated','#ffd34d'];
if (h.prolactin > .62 && h.serotonin > .50) return ['NURTURED','s-nurtured','#ff7ab8'];
if (h.adiponectin > .60 && h.prolactin > .50) return ['HEALTHY','s-healthy','#36d399'];
if (h.estrogen > .60 && h.serotonin > .52) return ['RECEPTIVE','s-receptive','#ff7ab8'];
if (h.aldosterone > .60 && h.serotonin > .55) return ['BALANCED','s-balanced','#36d399'];
if (h.growth_hormone > .62 && h.cortisol < .45) return ['GROWING','s-growing','#00ff7a'];
if (h.acetylcholine > .60 && h.norepinephrine > .55) return ['ATTENTIVE','s-attentive','#ffd34d'];
if (h.ghrelin > .64 && h.leptin < .46) return ['HUNGRY','s-hungry','#b48cff'];
if (h.leptin > .60 && h.serotonin < .46) return ['SATURATED','s-saturated','#7a7a8a'];
if (h.norepinephrine > .62) return ['FOCUSED','s-focused','#00e5ff'];Reads dozens of internal levels and picks one named state in strict priority order, with each tricky rule explained in place.
The engineering method behind all of it: software designed like a living body, with no single point of failure.
async function blockTime(key) {
const [url, half, trust] = RPC[key];
const t0 = now();
const r = await fetch(url, { method: "POST", headers: { "content-type": "application/json" },
body: JSON.stringify({ jsonrpc: "2.0", id: 1, method: "eth_getBlockByNumber", params: ["latest", false] }) });
const j = await r.json();
const ts = parseInt(j.result.timestamp, 16) * 1000;
// a block is stamped when it's made; on average "now" is half a block interval later, plus half the round trip
add(key, ts + half * 1000 + (now() - t0) / 2, trust, half * 1000);
}
async function serverTime() {
const t0 = now();
const r = await fetch(location.origin + "/health", { method: "HEAD", cache: "no-store" });
const d = Date.parse(r.headers.get("date"));
if (!isNaN(d)) add("server", d + 500 + (now() - t0) / 2, 0.6, 1000); // Date header has 1-second resolution
}
function fuse() {
add("device", Date.now(), 0.25, 0);
const t = now();
// bring every molecule forward to this instant using the monotonic stopwatch
const live = mols.filter(m => t - m.seen < FRESH_MS).map(m => ({ ...m, at: m.t + (t - m.seen), w: m.trust * Math.exp(-(t - m.seen) / FRESH_MS) }));
if (!live.length) return;
const sorted = live.map(m => m.at).sort((a, b) => a - b), mid = sorted[Math.floor(sorted.length / 2)];
const ok = live.filter(m => Math.abs(m.at - mid) <= ALIGN_MS);
const wsum = ok.reduce((s, m) => s + m.w, 0), tsum = live.reduce((s, m) => s + m.w, 0);
const T = ok.reduce((s, m) => s + m.at * m.w, 0) / (wsum || 1);
const spread = ok.length > 1 ? Math.max(...ok.map(m => m.at)) - Math.min(...ok.map(m => m.at)) : 0;
fused = { at: t, t: T, used: ok.length, total: live.length, spread, conf: Math.round((wsum / (tsum || 1)) * 100 * Math.exp(-spread / 15000)) };
}
function paint() {
if (!fused) { el.querySelector(".mc-t").textContent = "--:--:--"; return; }
const d = new Date(fused.t + (now() - fused.at));
el.querySelector(".mc-t").textContent = d.toLocaleTimeString([], { hour: "2-digit", minute: "2-digit", second: "2-digit" });
const mode = fused.used >= 3 && fused.conf >= 60 ? "CONFIRMED" : fused.used >= 2 ? "WATCH" : "WAIT";
el.querySelector(".mc-s").textContent = `${mode} · ${fused.used} of ${fused.total} clocks agree · ±${(fused.spread / 2000).toFixed(1)}s`;
}Shows the time by weighing four independent clocks, including two blockchains, discarding outliers and reporting its own confidence.
A role-playing game engine with zones, combat, quests, professions and saved progress, all drawn in code.
/* Apply a decided number.
Returns what ACTUALLY came off, not what was asked for. The
arena's old copy tallied the request, so 9999 into a target
with 40hp counted 9999 toward the 25-minute damage tiebreak.
`threat` accepts a number as well as a boolean, for the callers
that scale it — a spell's threatMult, the pet's reduced share. */
export function applyHit(source, target, amount, {
threat = true, pushback = 0.5, tally = true,
} = {}) {
if (!target) return { amount: 0, killed: false, pushback: 0 };
const before = target.hp;
target.hp = Math.max(0, before - Math.max(0, Math.round(amount)));
const dealt = before - target.hp;
if (tally) {
if (source) source._dmgDone = (source._dmgDone || 0) + dealt;
target._damageTaken = (target._damageTaken || 0) + dealt;
}
if (threat && source) {
const mult = typeof threat === 'number' ? threat : 1;
addThreat(target, source, dealt * mult * (source._derived?.threatMod || 1));
}
/* Taking a hit mid-cast delays it rather than cancelling it. */
let pushed = 0;
if (pushback > 0 && dealt > 0 && target.casting) {
target.casting.endsAt += pushback;
pushed = pushback;
}
return { amount: dealt, killed: before > 0 && target.hp <= 0, pushback: pushed };
}Six separate damage paths were merged into one, so the game counts what really came off a target, not what was asked for.
A real-time tower-battle card game for phones: 8-card decks, 3-minute matches, 10 arenas. Installs like an app.
function canTarget(a, e, area) {
if (!e.alive || e.side === a.side) return false;
if (e.hidden && !area) return false; // invisible: only area damage finds it
if (a.targets === 'buildings') return e.kind !== 'troop';
if (e.air) return a.targets === 'any' || a.targets === 'air';
return a.targets !== 'air';
}
function reach(a) { return a.range + (a.kind === 'troop' ? a.radius : 0); }
function inReach(a, t) {
var d = dist(a, t) - t.radius;
return d <= reach(a) && d >= a.minRange;
}
function findTarget(st, u) {
var stat = u.kind !== 'troop', bOnly = u.targets === 'buildings';
var sight = stat ? reach(u) : Math.max(5.5, u.range + 1);
var best = null, bd = Infinity, i, e, d;
var lists = [st.towers, st.units];
for (var L = 0; L < 2; L++) {
var arr = lists[L];
for (i = 0; i < arr.length; i++) {
e = arr[i];
if (!canTarget(u, e)) continue;
d = dist(u, e) - e.radius;
if (stat) { if (d > sight || d < u.minRange) continue; }
else if (!bOnly && d > sight) continue;
if (d < bd) { bd = d; best = e; }
}
}
if (best || stat) return best;
// nothing in sight: march on the nearest enemy building/tower
for (L = 0; L < 2; L++) {
arr = lists[L];
for (i = 0; i < arr.length; i++) {
e = arr[i];
if (!e.alive || e.side === u.side || e.kind === 'troop') continue;
d = dist(u, e) - e.radius;
if (d < bd) { bd = d; best = e; }
}
}
return best;
}Each troop checks what it is allowed to hit, finds the closest valid enemy, and marches on the nearest tower when nothing is in sight.
An XP and rank engine that rewards real work as it happens, up to the AI Master rank.
const XP_BASE = 600; // cost of level 1
const XP_GROW = 15; // each level costs this much more than the last
const LEVEL_CAP = 200;
/* ---- activity state machine (see header) ------------------------------------
Every one of these is a measured threshold on a measured signal. Nothing here
is a guess about intent: "FOCUSED" means input landed inside IDLE_ACTIVE
seconds, no more and no less. */
const IDLE_ACTIVE = 25; // s since last input and you still count as hands-on
const SCREEN_MOVING = 0.010; // mean per-pixel change above this = screen is busy
const SCREEN_ALIVE = 0.0015; // ...above this = something is redrawing at all
const FOCUS_CHUNK_MS = 5 * 60e3;// ACTIVE time that buys one DEEP FOCUS award
const FOCUS_CHUNK_XP = 20; // per chunk. 8h of true hands-on ~ 96 xp/hr ceiling
const DEEP_BREAK_MS = 90e3; // a gap this long ends an unbroken deep-work run
const DEEP_MARKS = [15, 30, 60, 90, 120]; // minutes worth announcing
const POPUP_MIN_GAP = 2500; // ms between desktop cards so they cannot stack up
/* cumulative XP required to HAVE reached level L */
const cumXP = L => XP_BASE * L + XP_GROW * L * (L - 1) / 2;
const costOf = L => XP_BASE + XP_GROW * (L - 1); // cost of the step INTO level LLevels follow one clear formula, and focus only earns XP when real input was measured in the last 25 seconds, never a guess.
Build 3D models out of blocks and export them ready for a 3D printer (STL / 3MF).
function triNormal(t){
const [a,b,c]=t.v;
const u=[b[0]-a[0],b[1]-a[1],b[2]-a[2]],w=[c[0]-a[0],c[1]-a[1],c[2]-a[2]];
let n=[u[1]*w[2]-u[2]*w[1],u[2]*w[0]-u[0]*w[2],u[0]*w[1]-u[1]*w[0]];
const l=Math.hypot(...n)||1;return [n[0]/l,n[1]/l,n[2]/l];
}
function writeSTLBinary(tris,name){
const bufr=new ArrayBuffer(84+tris.length*50),dv=new DataView(bufr);
const hdr='PIXELATOR3D · '+name;
for(let i=0;i<Math.min(79,hdr.length);i++)dv.setUint8(i,hdr.charCodeAt(i));
dv.setUint32(80,tris.length,true);
let o=84;
for(const t of tris){
const n=triNormal(t);
dv.setFloat32(o,n[0],true);dv.setFloat32(o+4,n[1],true);dv.setFloat32(o+8,n[2],true);o+=12;
for(const v of t.v){dv.setFloat32(o,v[0],true);dv.setFloat32(o+4,v[1],true);dv.setFloat32(o+8,v[2],true);o+=12;}
dv.setUint16(o,0,true);o+=2;
}
return bufr;
}Turns a voxel model into the standard file every 3D-printer slicer reads, computing each triangle's facing direction exactly.
The private admin behind this site: requests ranked by urgency, then clients with jobs, prices and paid/owed totals.
/* sessions */
const hashSid = sid => crypto.createHash('sha256').update(sid).digest('hex');
const cookieOf = req => { const m = (req.headers.cookie || '').match(new RegExp('(?:^|;\\s*)' + COOKIE + '=([a-f0-9]{64})')); return m ? m[1] : null; };
const https = req => (req.headers['x-forwarded-proto'] || '').split(',')[0].trim() === 'https';
const cookie = (req, sid, ms) => `${COOKIE}=${sid}; Path=/; HttpOnly; SameSite=Strict${https(req) ? '; Secure' : ''}; Max-Age=${Math.floor(ms / 1000)}`;
function session(req) {
const sid = cookieOf(req); if (!sid) return null;
const s = sessions[hashSid(sid)];
if (!s || s.exp < Date.now() || !account || s.user !== account.user || s.gen !== account.changed) return null;
return s;
}
async function startSession(req, res, remember, body) {
const sid = crypto.randomBytes(32).toString('hex'), ms = remember ? LONG : SHORT;
const now = Date.now(); for (const [k, v] of Object.entries(sessions)) if (v.exp < now) delete sessions[k];
sessions[hashSid(sid)] = { user: account.user, csrf: crypto.randomBytes(24).toString('hex'), exp: now + ms, gen: account.changed };
saveSessions();
send(res, 200, { ok: true, ...body }, undefined, { 'set-cookie': cookie(req, sid, ms) });
}
// a signed-in owner may read; a change also needs the matching x-csrf header (a plain cross-site form can't send one)
function signedIn(req) {
const s = session(req); if (!s) return false;
if (req.method === 'GET' || req.method === 'HEAD') return true;
return same(req.headers['x-csrf'] || '', s.csrf);
}
/* wrong-password lockout, per sender address (hashed) */
const tries = new Map();
const locked = req => { const t = tries.get(ipKey(req)); return t && t.until > Date.now() ? Math.ceil((t.until - Date.now()) / 60e3) : 0; };
function failed(req) {
const k = ipKey(req), t = tries.get(k) || { n: 0, until: 0 };
t.n++; if (t.n >= FAILS) { t.until = Date.now() + LOCK; t.n = 0; } tries.set(k, t);
}
setInterval(() => { const now = Date.now(); for (const [k, v] of tries) if (v.until < now && !v.n) tries.delete(k); }, LOCK).unref();
const slow = () => new Promise(r => setTimeout(r, 400 + Math.random() * 400));
const pwProblem = pw => pw.length < 12 ? 'Use at least 12 characters.' : pw.length > 200 ? 'That password is too long.' : '';Logins use hashed session IDs, secure cookies, cross-site request protection and a lockout after repeated wrong passwords.
A free forum built for Google: real pages, quick-fix guides, and every post checked by a person before it appears.
const clean = s => str(s, 5000).replace(/\r\n/g, '\n');
const linky = s => (s.match(/https?:\/\/|www\./gi) || []).length;
return async function handle(req, res, url) {
const p = url.pathname;
if (req.method === 'GET' || req.method === 'HEAD') {
if (p === '/sitemap.xml') { sitemap(req, res); return true; }
if (p === '/forum' || p === '/forum/') { home(req, res); return true; }
let m = p.match(/^\/forum\/t\/([a-f0-9]{10})(?:\/[a-z0-9-]*)?$/);
if (m) { const t = live().find(x => x.id === m[1]); if (!t) return false;
if (!p.endsWith('/' + t.slug)) { res.writeHead(301, { location: threadUrl(t) }); res.end(); return true; }
threadPage(req, res, t); return true; }
m = p.match(/^\/forum\/([a-z0-9-]+)\/?$/);
if (m) { const tp = TOPICS.find(x => x.id === m[1]); if (!tp) return false; topicPage(req, res, tp); return true; }
}
if (p === '/api/forum/thread' && req.method === 'POST') {
if (limited(req)) { send(res, 429, { ok: false, error: 'Too many posts. Please wait a few minutes.' }); return true; }
const b = await readBody(req);
if (str(b.company_website, 200)) { send(res, 200, { ok: true }); return true; } // bot trap
const topic = TOPICS.find(t => t.id === b.topic), title = str(b.title, 140), body = clean(b.body), name = str(b.name, 60);
if (!topic) { send(res, 400, { ok: false, error: 'Please pick a topic.' }); return true; }
if (title.length < 8 || body.length < 15 || name.length < 2) { send(res, 400, { ok: false, error: 'Please add your name, a one-line question and a few details.' }); return true; }
if (linky(title + ' ' + body) > 2) { send(res, 400, { ok: false, error: 'Please keep links to two or fewer.' }); return true; }
db.threads.push({ id: crypto.randomBytes(5).toString('hex'), slug: slugify(title), topic: topic.id, title, body, name, owner: false, pinned: false,
at: new Date().toISOString(), status: 'pending', replies: [] });
save(); send(res, 201, { ok: true }); return true;
}
if (p === '/api/forum/reply' && req.method === 'POST') {
if (limited(req)) { send(res, 429, { ok: false, error: 'Too many posts. Please wait a few minutes.' }); return true; }
const b = await readBody(req);
if (str(b.company_website, 200)) { send(res, 200, { ok: true }); return true; }
const t = live().find(x => x.id === str(b.thread, 20)), body = clean(b.body), name = str(b.name, 60);
if (!t) { send(res, 404, { ok: false, error: 'That thread is no longer available.' }); return true; }
if (body.length < 5 || name.length < 2) { send(res, 400, { ok: false, error: 'Please add your name and a reply.' }); return true; }
if (linky(body) > 2) { send(res, 400, { ok: false, error: 'Please keep links to two or fewer.' }); return true; }
t.replies.push({ id: crypto.randomBytes(5).toString('hex'), body, name, owner: false, at: new Date().toISOString(), status: 'pending' });
save(); send(res, 201, { ok: true }); return true;
}New posts pass a bot trap, rate limit and link cap, then wait for a person to approve them before anyone sees them.
Runs 255 checks on a website and writes a plain report with the evidence. This is a real one, run on liqua.network.
/* — 2. transport security — */
if(out.measured.scheme !== "https"){
push("no_https", "Site does not serve over HTTPS", W.no_https,
"final URL is " + page.finalUrl + " — browsers label this Not Secure", page.finalUrl);
} else {
const cert = await certInfo(domain);
out.measured.cert = cert;
if(cert.ok){
if(cert.daysLeft != null && cert.daysLeft < 0){
push("cert_expired", "TLS certificate has expired", W.cert_expired,
"expired " + Math.abs(cert.daysLeft) + " days ago (valid_to " + cert.validTo + ")", "https://" + domain);
} else if(cert.daysLeft != null && cert.daysLeft <= (cfg.certWarnDays || 21)){
push("cert_expiring_soon", "TLS certificate expires in " + cert.daysLeft + " days", W.cert_expiring_soon,
"valid_to " + cert.validTo + " · issuer " + cert.issuer, "https://" + domain);
}
if(!cert.authorized && cert.authorizationError && !/CERT_HAS_EXPIRED/.test(cert.authorizationError)){
push("cert_invalid", "TLS certificate fails validation", W.cert_invalid,
cert.authorizationError + " · CN " + cert.subject, "https://" + domain);
}
}
const mixed = (html.match(/(?:src|href)\s*=\s*["']http:\/\/[^"']+/gi) || [])
.filter(s => !/http:\/\/(www\.)?(w3\.org|schema\.org|purl\.org|ogp\.me|gmpg\.org)/i.test(s));
if(mixed.length){
out.measured.mixedContentCount = mixed.length;
push("mixed_content", mixed.length + " insecure http:// asset reference(s) on an https page", W.mixed_content,
mixed.slice(0, 3).join(" | "), page.finalUrl);
}
}Each finding about a site's HTTPS, certificate or insecure assets is backed by the exact measured evidence shown to the owner.
Six complete schools with 380 lessons, auto-marked drills and progress tracking. They work offline too.
/* Whitespace is collapsed and trimmed BEFORE trailing punctuation is stripped.
The other order leaves the full stop attached whenever the answer ends in a
space, and a correct answer gets marked wrong for it. */
const norm = s => String(s).toLowerCase()
.replace(/[‘’]/g, "'").replace(/[“”]/g, '"')
.replace(/\s+/g, ' ').trim()
.replace(/[.,;:!?]+$/, '').trim();
/* Numbers are compared numerically, not as strings, so 0.5 · .5 · 0.50 all
pass. Commas and spaces used as thousands separators are stripped; a bare
fraction like 3/4 is evaluated. Tolerance defaults to a relative 0.1%. */
function parseNum(s) {
const t = String(s).replace(/[, ]/g, '').replace(/^\+/, '').trim();
if (/^-?\d+(\.\d+)?\/-?\d+(\.\d+)?$/.test(t)) {
const [a, b] = t.split('/').map(Number);
return b === 0 ? NaN : a / b;
}
const v = Number(t);
return Number.isFinite(v) ? v : NaN;
}
function numOK(given, want, tol) {
const g = parseNum(given);
if (!Number.isFinite(g)) return false;
const t = tol != null ? tol : Math.max(1e-9, Math.abs(want) * 0.001);
return Math.abs(g - want) <= t;
}Students are not marked wrong for a stray full stop or for writing 0.5 as .5 or 1/2; numbers are compared as numbers.
Narrated AI and development courses with free preview chapters, built to sell online.
function cutSections(html, cut) {
const start = html.indexOf(`<section id="c${cut}">`);
if (start < 0) throw new Error(`no <section id="c${cut}"> found`);
const end = html.indexOf(DRAWER_MARK);
if (end < 0) throw new Error('no transcript-drawer marker found');
// The removed span also swallows the </div> that closes .wrap —
// wallHtml() re-emits it.
return {
head: html.slice(0, start),
tail: html.slice(end),
removed: html.slice(start, end),
};
}
/* Every id="" inside the removed HTML gets a hidden empty stub, so the
page's own scripts can still getElementById() without throwing. */
function stubsFor(removedHtml) {
const ids = [...removedHtml.matchAll(/\sid="([^"]+)"/g)]
.map(m => m[1])
.filter(id => !/^c\d+$/.test(id)); // chapter anchors aren't needed
const uniq = [...new Set(ids)];
if (!uniq.length) return '';
return (
'\n<div hidden aria-hidden="true" data-preview-stubs>' +
uniq.map(id => `<div id="${id}"></div>`).join('') +
'</div>\n'
);
}Free previews physically cut the paid chapters out of the file, so there is no hidden unlock for anyone to bypass.
My whole method in one file: Molecular Coding, 74 rules and a 20-point A-grade checklist. Paste it into any AI assistant.
You don't need to know what's wrong. That's my job. If it's a computer, I work on it. I come to your home or office anywhere within 50 miles of Houston. I find the problem and tell you the price. Then I fix it, usually that same day.
🆓 Free assessment and quote anywhere within 50 miles of Houston. You never pay for anything but what I repair. Most repairs start at $59.
Use the form at the bottom of the page. I'll reply with a few questions and a time.
I come to you, or you drop it off. I find the real problem and explain it in plain English, free.
A fixed price before any work. If it isn't worth fixing, I'll say so.
I test it in front of you, so you know it works before I leave.
This area is for on-site repairs and installs. Software work is available worldwide. Type your town to check. Distances are approximate, measured in a straight line from downtown Houston.
You run the business. I set up the AI, connect it to your tools, and keep it working. Practical AI built into the way you already work, with a person checking anything that matters before it goes out. Available worldwide.
Sort incoming email, flag what's urgent, and draft replies in your voice for you to approve.
See details →Summarize long documents, pull out key dates and terms, and compare versions in seconds.
See details →Read invoices, receipts and forms, and put the numbers straight into your spreadsheet or accounting.
See details →Turn recordings into clean notes, decisions and an action list, sent to the right people.
See details →Draft weekly reports, quotes and proposals from your own data and templates.
See details →An assistant on your website that answers from your own FAQs and hands off to a person.
See details →I start with the task that eats the most hours, not a company-wide overhaul.
A short pilot with your own documents and emails, so you see real results.
I count the time it actually saves and the mistakes it catches, before you spend more.
Your team is trained, it's documented, and your data stays private.
Beyond repairs, I engineer, build, program and install complete systems myself, for a business of any size. One person on the whole job, so nothing gets lost between contractors, and you never have to manage the tech. Pick one to see what's involved.
Private AI servers, assistants trained on your documents, and AI features in your software.
AI solutions →Tokens, smart contracts and blockchain apps, with full test suites before anything goes live.
Blockchain →From one rig to a warehouse: hardware, power planning, cooling coordination and monitoring.
Mining operations →Websites and apps hosted, backed up and monitored, with a real person to contact.
Managed hosting →File servers, app servers and private cloud, on your premises or in a data center.
Servers →Planning GPU, mining and server rooms: layout, power budget, airflow and monitoring.
Facility planning →Bots, alerts and automations that take repetitive work off your plate.
Automation →Logos, prompt packs, AI art, templates, printables, e-books, music and 3D-print models, made for you.
Digital goods →If it runs on a computer, I can probably build it. Describe it and I'll give you a straight answer.
Tell me about it →From a one-page website to a full platform. You're never left wondering what's happening.
Send a short message using the Get help form. I'll ask a few questions so I understand what you need.
One fixed price, with what's included written down. Nothing starts until you say yes.
You'll get a link to see it taking shape and can ask for changes along the way.
I hand everything over and show you how it works. I'm still here if you need help later.
What this means for you: fewer bugs, faster fixes, and when one part has a problem, the rest keeps working.
This is my own engineering method. I design every program the way a body works. There are layers that protect, systems that deliver, filter and heal, and rules you can actually check. It's why my work is fast and holds up. Read the full spec ↗
Not just theory. Here's where the method is working on this page right now:
| Body system | What it does on this site |
|---|---|
| 🧱 Skin | The server only opens folders that are meant to be public, and sends security headers with every page. |
| 🛡️ Immune | A hidden trap catches spam bots, repeat senders are slowed down, and your sales dashboard is locked with a private key. |
| 🫘 Kidneys | Every form field is cleaned and size-limited before it's saved, so bad data never gets in. |
| 🩸 Blood | Your request travels form → server → saved file → my dashboard, and files are saved in one step so they can't half-save. |
| 📜 Ledger | Every change to a request is written to its history with the time, and never edited after. |
| 👁️ Senses | The area checker and the speed check measure real things: real distances and your browser's real load times. |
| ⚖️ Homeostasis | The alert demo uses a threshold and a cool-down, so one problem sends one alert, not fifty. |
| 🏷️ Truth stickers | Simulated demos say "simulated", distances say "approximate", and the stats say when they were counted. |
| ⏱️ Law Zero | Nothing on the page waits on anything else. If the server is down, the form keeps everything you typed so you can send it again. Missing tools hide themselves. |
One engineer with 30 years of computer experience, including 10 years experience in blockchain and AI. I design, build, program and install the whole system. I work alongside your IT team, not around them, so your people stay focused on the business. If a project needs more people, I'll say so up front and plan for it.
Connect your CRM, accounting, Microsoft 365 / Google Workspace and in-house systems so data flows without re-typing.
Replace spreadsheets and email chains with tools that have role-based access, approvals and a full audit trail.
Customer, partner and staff portals where people sign in once with their work account, data is encrypted, and every action is logged.
Take over aging or abandoned software, document it, fix it, and move it forward without a risky big-bang rewrite.
Document search and assistants that run on your own servers, so sensitive data never leaves your control.
Planning, rack layout and live monitoring for GPU, mining and server rooms: power, heat and uptime on one screen.
Built a 6,000 sq ft GPU mining facility from an empty warehouse, working with one licensed electrician and one HVAC contractor. I planned the layout, rigs and monitoring; they handled the electrical and cooling. That's the same hands-on understanding of power, heat and keeping systems running that I bring to yours.
🌎 Software services are available worldwide, delivered remotely. Hands-on repairs and installs cover everywhere within 50 miles of Houston.
Services start at $59 · Every job gets one fixed price before work starts
Pick a category or search. Click + Add to my request on anything that interests you. When you're ready, press Get help at the top: everything you added is already filled in.
These are small working examples of what I build. They're not videos: click the buttons, type in the boxes, and see what happens. Nothing you do here can break anything. Want to see bigger projects? Try them live and read the code
Paste any CSV (or edit the sample). It becomes a sortable table, totals and a chart instantly. Click a column header to sort it.
The checks I run on client sites, run right now on this page with your browser's own Performance API. These are real numbers from your load, not a canned report.
Paste messy text, such as an email thread, a web page or a listing dump. The extractor pulls out the structured data. Scrapers I build do this across thousands of pages.
A Telegram-style bot you can talk to. Try /help, /poll Pizza or tacos?,
/remind 10 stretch, /roll, or paste a spammy message with a link and watch moderation step in.
A miniature token ledger with the same rules as an ERC-20: balances, transfers, allowances, and a fixed supply. Run its test suite, then try to break it yourself. Every contract I ship comes with tests like these.
Packet Runner, a small original game: catch green data packets, dodge red viruses. Steer with the mouse, your finger, or ← →. Same canvas engine approach as my arcade builds.
A simulated sensor (say, a GPU temperature) feeding a real alert rule: a threshold, a required duration and a cooldown, so you get one useful ping instead of fifty. Drag the controls and watch.
You never pay for anything but what I repair or build. Assessments, quotes and advice are always free. For software, pick what suits you.
For a new website, booking system or piece of software. One price for the whole job.
I look after your website for a flat monthly fee, so you never have to think about it.
A website or app is broken right now. I find the problem, tell you the price, and fix it.
Type in your web address and my checker looks for problems: whether it's safe, whether it works on phones, how fast it loads, whether Google can find it, and broken links. You'll see the top three problems for free, explained in plain English.
Check my website for free💬 Just a quick question? Ask it free in The Tech Den, my forum for computers, AI, websites and crypto.
No technical words needed. Describe it the way you'd tell a friend, and I'll work out the tech. I only need your email and a few words. Click Send my request and it comes straight to me. I reply by email.
Your details are only used to reply to you.
Not at all. That's the point: you run the business, I run the tech. Most of the people I work with aren't. I'll explain everything in plain English, I won't rush you, and no question is too basic.
Yes, for software. Websites, apps, automation, AI, hosting and blockchain work are all done remotely for clients anywhere in the world. Only hands-on repairs and installs are limited to Houston and 50 miles around.
Yes. I’m happy to sign an NDA before we talk details, work inside your code repositories and ticketing system, follow your security and change-approval process, and work with your procurement team on contracts and invoicing. Everything is documented so your own staff can take it over.
I show you how to use it, hand over all the logins, and stay available for questions. If you'd rather not deal with it at all, the monthly care plan means I look after it for you.
Starting at is the simplest version of the job. Typical is what most jobs like it come to. Either way, you get one fixed price for your job before any work starts, and it doesn't change unless the job does. Parts and hardware are extra where it says so.
Yes, all of it: source, repositories, hosting accounts, domains and docs. If we stop working together tomorrow, you lose nothing.
Usually, yes. It starts with a measured look at what's there. You'll get an honest read on whether to fix it or rebuild, with the reasons.
No. I won't build scams, fake reviews, dark-pattern funnels, or anything that promises guaranteed returns. Crypto work comes with real tests and honest disclaimers.
You never pay for anything but what I repair or build. Assessments, quotes and advice are free. Larger projects are split into milestones, and you pay as each working piece is delivered, so you're never far ahead of the work.