Boris Nikolic
Software developer · Belgrade, Serbia
I build platforms and ship software with AI agents in the loop.
Started with robots in middle school, got hooked on Linux in a VM, learned the trade through Hack The Box and frontend work in high school, and have spent the last two years building software for a living while finishing a Software Engineering degree.
Backend services and APIs: Go, Python, NestJS; REST design, auth, gateway-fronted services
Odoo modules and PostgreSQL: ERP modules, query optimization, triggers, reporting over large datasets
ERP integration and data replication: Odoo data into analytical warehouses, built for reliable delivery
AI-assisted engineering: Claude Code, role prompts, plugins, MCP servers for pipelines and infrastructure
Full-stack delivery: Next.js and React frontends, JWT auth, payments, admin tooling
Linux and self-hosting: Ubuntu servers, iptables firewalls, SSH hardening, monitoring, Docker Compose
Working with stakeholders: Direct communication, technical terms explained in plain language to non-technical people, delivery against what they actually need
Type a command and press Enter. Tab completes, arrow keys browse history, Ctrl+L clears.
How I work with AI
AI is part of how I ship software, not an autocomplete on the side. Tools come and go; the loop stays: brief, plan, build with tests, review, verify, document. The agent gets the same context a new teammate would, written down in the repository.
loop
Every task, every repository, the same six steps.
- briefA written brief with goals, constraints, and integrity rules: what the agent may and may not invent.
- planBrainstorm, then a written plan before code. Specs and plans are committed next to the code.
- buildSmall tasks, tests first where the stack allows. The agent works from CLAUDE.md and the docs hierarchy, not from chat memory.
- reviewAI review passes (code review, security review) followed by my own read of every change.
- verifyLint, build, run, and drive the actual app before anything is called done.
- documentSTATUS, CHANGELOG, and open-question files so the next session, human or agent, starts with context.
prompting
Prompts are repository files with a job, a reading order, rules, and a done checklist. They are versioned like code and reviewed like code.
- Role prompts per job: a Builder prompt for features and fixes, a Testing prompt for coverage, each with its own goal, workflow, and checklist.
- A docs hierarchy the agent reads first: CONTEXT.md, STATUS.md, coding standards, and the security remediation plan.
- Hard rules as NEVER / ALWAYS lists (no secret logging, parameterized SQL, crypto/rand only) that come before style preferences.
- A reporting format for finished work: what changed, files, tests added, breaking changes, next steps.
- An example session in the prompt so the agent sees a full loop, not just rules.
- Tool inventory in CLAUDE.md: which commands, plugins, and MCP servers exist, so the agent uses real tools instead of guessing.
claude code
Claude Code is the daily driver, configured per repository rather than per chat.
- CLAUDE.md per repo
- Stack, commands, architecture, content rules, and the inventory of tools the agent can use.
- superpowers plugin
- brainstorming, writing-plans, test-driven-development, systematic-debugging, verification-before-completion.
- engineering plugin
- code review, debugging, architecture decision records, deploy checklists, and the MCP connectors it ships with.
- qodo-standards plugin
- Managed coding rules loaded into the session before code is written.
- memory and specs
- Persistent memory files plus written specs and plans committed next to the code.
mcp servers
MCP servers give the agent real tools instead of pasted output. Which servers and tools exist is declared in the project config, so the agent knows exactly what it can call.
- GitLab
- Pipeline automation from Claude: merge requests, pipeline status, and job logs without leaving the session.
- cloud infrastructure
- Managing infrastructure resources through MCP tools, with the same review loop as code changes.
- issue and ops trackers
- GitHub, Jira and Confluence, Linear, Datadog, and PagerDuty connectors from the engineering plugin, enabled per project.
- browser
- Claude drives a browser against the running app: screenshots, console, DOM checks, keyboard navigation.
environment
The tools around the agent, all terminal-first.
- Neovim (LazyVim) as the editor
- tmux and lazygit in the terminal
- Linux on every machine
- Claude Code and Codex as the agents; local LLMs for experiments
Case studies
Two entries: client work on Odoo for Fairphone, and a full-stack personal project. The client page says only what the engagement allows.
client work
Fairphone
2025 – present
fairphone-odoo-platform/ Client Work: Odoo Platform for Fairphone
Platform work for Fairphone on Odoo: modules for sustainability and procurement operations, replication of ERP data into analytical warehouses, and the architecture of a customer-facing shop. Described at the level the engagement allows.
role: Software developer
- Odoo
- PostgreSQL
- Data replication
personal project
University project
toy-store/ Toy Store: Full-Stack E-commerce
A full-stack e-commerce application with a Go API, a Next.js 14 frontend, PostgreSQL, Redis-backed sessions and caching, Stripe checkout, and an admin dashboard, run as one Docker Compose stack behind Nginx.
role: Developer
- Go
- Next.js
- PostgreSQL
- Redis
- Stripe
50+ personal and client projects since school. Most are private, old, or under agreements not to talk about them. The ones on this page are the ones I can show.
Working with people
- Direct communication with stakeholders, no layer in between.
- Explaining technical terms and trade-offs in plain language to non-technical people.
- Working alongside the people who use the software, from the first requirement to delivery.
Also built
Control Management System Platform
Multi-role CMS web application with authentication, order management, revenue reports, a notification system, and role-based access control.
Go · Next.js · React · TypeScript · PostgreSQL
RPG campaign manager (university coursework) (opens in a new tab)
Final project for the Internet Software Architecture course: a Spring Boot REST API with JWT access and refresh tokens and role-based authorization, a React SPA, PostgreSQL, and Docker Compose. Game masters run campaigns, sessions, and item catalogs; players manage characters and inventories.
Java 21 · Spring Boot · PostgreSQL · React · Docker Compose
Home lab
Hosting my own servers, configuring and hardening them, and automating the whole thing. It started with Hack The Box, which is where Linux, Git, Nmap, and Kali Linux came from.
- servers:
- Self-hosted Ubuntu machines, including a Forgejo git forge for my own repositories.
- network:
- Home network and custom iptables firewall rules for the self-hosted services.
- hardening:
- SSH hardening automated end to end with a script I built after researching what hardening should cover.
- monitoring:
- Grafana and Prometheus over the whole stack.
- experiments:
- Local blockchains, for learning.
- origins:
- Hack The Box: Linux, Git, Nmap, Kali Linux.
About
I write software for a living and for fun. Two years in, most of the paid work has been backend and data systems: Odoo modules, ERP data replication, and the services around them. Beside the home lab, the rest of the time goes into finishing university.
AI agents are part of the everyday loop: written briefs and role prompts, Claude Code and Codex with plugins and MCP servers, and my own read of every change before it ships. I love what I do.
university
BSc Software Engineering. Enrolled in 2023, finishing by the end of 2027, working as a software developer alongside it.
off the keyboard
- Sim racing, Counter-Strike, and cars.
- The gym, trying to stay in shape.
- A good meal: pasta, or anything protein-rich.
How I work
- Model the domain before the endpoints
- Schemas, states, and invariants come first. APIs and screens follow from them.
- Design for failure
- Acknowledgments, retries, and idempotent steps, so a crash midway becomes a retry instead of a data gap.
- Measure the database
- Query plans and real data volumes before optimizing. PostgreSQL usually has the answer.
- Keep boundaries clear
- Layers and services that can be understood, tested, and changed on their own.
- AI in the loop, developer accountable
- Agents work from written briefs and rules; every change is read, understood, and verified by me.
- Automate what would otherwise repeat
- If something has to be done twice, it gets a script: server hardening, pipelines, reports.
Technologies, grouped by how I've used them
First-level items are in regular use on client and personal work; entries marked (also) are used less often or in specific projects.
Languages/
Go for services and CLIs, Python for Odoo and data tooling, Rust for a client platform, TypeScript across NestJS and Next.js, SQL daily in PostgreSQL.
- Go
- Python
- Rust
- TypeScript
- SQL
- JavaScript (also)
- Java (university projects) (also)
- PHP (university projects) (also)
- C/C++ (personal systems projects) (also)
Backend and APIs/
Odoo module development, layered Go services, NestJS services, and gateway-fronted APIs with JWT auth and role-based access.
- Odoo module development
- Go (Gin, chi)
- NestJS / Node.js
- REST API design
- JWT auth and RBAC
- Stripe integration (also)
- Prisma (also)
- API gateway pattern (also)
Data and storage/
PostgreSQL as the system of record: query optimization over large datasets, triggers, migrations. Redis for caching and sessions.
- PostgreSQL
- ERP data replication
- Redis
- Query optimization
- MongoDB (also)
- SQLite (also)
- Analytical warehouses (also)
Messaging and workflows/
Asynchronous pipelines with RabbitMQ, scheduled jobs, and reliable delivery for data replication.
- RabbitMQ
- Event-driven design
- Scheduled jobs
- Reliable delivery
Frontend/
Next.js App Router with server components where it helps SEO and data loading, client state only where the UI needs it.
- React
- Next.js (SSR)
- Tailwind CSS
- Zustand (also)
- Zod (also)
- Axios (also)
Infrastructure and operations/
Self-hosted Ubuntu servers in the home lab with Grafana and Prometheus over them; every project ships with a Docker Compose setup and a reverse proxy where needed.
- Linux
- Ubuntu servers
- Docker and Docker Compose
- Nginx
- Grafana
- Prometheus
- Forgejo (self-hosted) (also)
- CI/CD pipelines (also)
- Vercel (also)
- Makefiles (also)
Security and networking/
Hack The Box is where this started; the home lab is where it is applied: firewalls, hardening, and the tooling to check the result.
- iptables firewalls
- SSH hardening (automated)
- Nmap
- Kali Linux
- PGP handling (also)
- Data encryption (also)
Architecture and practices/
Distributed data movement with explicit failure handling, clean layer and service boundaries, and domain models that match how the business actually works.
- Distributed systems
- Domain modeling
- Layered (clean) architecture
- Caching strategies
- Fault-tolerant data pipelines
AI-assisted workflow/
Agents in the delivery loop: Claude Code and Codex configured per repository, role prompts and agent instruction files, plugins for planning and review, and MCP servers so the agent can act on pipelines and infrastructure.
- Claude Code
- Codex
- CLAUDE.md and role prompts
- superpowers plugin
- engineering plugin
- MCP servers
- qodo-standards plugin (also)
- Local LLMs (also)
Tools/
Terminal-first: Neovim with LazyVim, tmux, lazygit, Git.
- Neovim (LazyVim)
- tmux
- lazygit
- Git
How I got here
From school robots to shipping software, one commit at a time.
- feat: software developerTwo years of building software for a living. Today: Odoo modules and data systems for Fairphone, with AI agents in the loop.
- feat: software engineering, universityBSc Software Engineering: enrolled in 2023, finishing by the end of 2027.
- feat: hack the box, high schoolHack The Box is where Linux, Git, Nmap, and Kali Linux really came from. Same years: custom frontends in HTML, CSS, and JavaScript, then React.
- feat: linux in a vmGot hooked on Linux running in virtual machines on Windows 10.
- init: robots, middle schoolFirst programs, written for school robots in a language long since forgotten. The interest stuck.
education: Bachelor of Software Engineering, enrolled 2023, finishing by the end of 2027
Open to interesting projects and opportunities
Backend-heavy full-stack roles and contract work, especially data and integration systems. Email is the fastest way to reach me.