Building with Claude

AI-augmented security engineering

I use Claude Code as a force multiplier — I design the system, define the security requirements, and review every line; Claude handles the implementation speed. These are the projects that came out of that workflow.

Working this way has taught me as much about constraining AI systems as about building with them. The autonomous agent below is the clearest example: the interesting engineering isn't the automation, it's the guardrails around it — scope, verification, and an audit trail that can't be skipped.

Threat intelligence

Threat-Intelligence Dashboard

A personal security operations start page.

A Next.js 14 application that pulls cybersecurity advisory and news feeds — The Hacker News, Krebs on Security — into one continuously refreshed view, alongside calendar and task data so security reading stays in the daily loop rather than a bookmarks folder.

Security-relevant decisions: every credential (Notion, Google Calendar) is read from environment variables and excluded from version control; no authentication data is stored client-side; the deployment is a static/edge build on Vercel with no database to harden. It's a small app, but it was built with the same secrets-hygiene discipline a production service needs.

  • Next.js 14
  • TypeScript
  • Tailwind CSS
  • RSS / OSINT ingestion
  • Environment-based secrets
  • Vercel

AI security

Autonomous Agent with Least-Privilege Guardrails

The engineering is in the constraints, not the automation.

An unattended agent that runs on a schedule with authority to act on exactly one account. The design treats the AI as an untrusted actor that must be boxed in:

  • Hard scoping. One authorized account ID, verified on every run before any read or write. A second account is explicitly off-limits — never read, never queried.
  • Verification before action. Every state-changing operation is previewed and re-checked against live data before it executes; nothing is logged as done until the result is confirmed from the source of truth.
  • Immutable audit trail. Every run — including runs that change nothing — appends an entry with timestamp, actions taken, and rationale. Existing entries are never modified.
  • Fail closed. If the account check fails or the scope can't be confirmed, the agent stops and logs the failure instead of proceeding.

These are ordinary security principles — least privilege, segregation of duties, non-repudiation — applied to a new kind of system. That translation is the part I find most interesting about where security is heading.

  • Least Privilege
  • Guardrail Design
  • Immutable Audit Log
  • Fail-Closed Logic
  • Scheduled Automation

Research

Red Team & OSINT Knowledge Base

128 cross-linked notes, every offensive technique paired with its defense.

A structured reference library I built to learn offensive security properly: MITRE ATT&CK tactics and techniques, command-and-control infrastructure, Active Directory attack paths and post-exploitation tooling, and a full OSINT investigation methodology — geolocation, SOCMINT, reverse-image, corporate footprinting.

Every tool and technique note follows one template: Overview · Demo Walkthrough · Detection & Defense · Official Resources, with ATT&CK technique IDs throughout. The point is that you can't defend what you don't understand, and you shouldn't study offense without immediately mapping the blue-team side.

Scope: all content is for authorized use only — home lab, CTFs, and engagements with written permission. No weaponized code, no real-target examples; every note assumes the ethics and scoping discipline of a proper engagement.

  • MITRE ATT&CK
  • C2 Infrastructure
  • Active Directory
  • OSINT
  • Detection Mapping
  • Zero broken links

Automation

Coursework Knowledge Automation

Turning four years of raw course files into a verified, cross-linked archive.

A pipeline for converting scanned PDFs, source code, and notebooks from my Pitt CS coursework into a consistently structured Obsidian vault: standardized frontmatter, per-course maps of content, and duplicate detection so the same lecture doesn't get transcribed twice.

The part worth mentioning here is verification — a scripted link-integrity check extracts every internal reference and diffs it against the actual file set after every batch, so the archive never silently drifts into broken links. Same instinct as writing tests: don't trust the change, prove it.

  • Document Pipeline
  • Link-Integrity Verification
  • Duplicate Detection
  • Obsidian

A note on how this was built

This website was also built with Claude Code — hand-written static HTML, one shared stylesheet, no framework. I directed the structure, content, and design; Claude did the typing. Same workflow as everything above.