My contribution
I built the plugin and its agent orchestration workflow, connecting development stories with specialized agents that carry out the work.
Enterprise software · Since 2020
Java Backend
Engineer.
Enterprise systems. AI-assisted development.
Building enterprise and financial software, from technical scoping and implementation to code review and production support. Alongside Java development, I build tooling that coordinates AI agents through a test-driven workflow.
JavaSpring BootKafka
JAVA SPRING BOOT KAFKA POSTGRESQL
Warsaw, Poland
01 Professional experience
From business stories
to production support.
The full story in my CV - — Present CURRENT ROLE
Fullstack Developer / IT Delivery Engineer
Raiffeisen Bank International
Developing functionality for financial services in a distributed, event-driven environment, with Java and Spring Boot services, Kafka integrations, and Angular interfaces.
- Translate business stories into technical scope and contribute to backlog refinement.
- Implement new functionality and business workflows, including work with Camunda and Flowable.
- Support production services through monitoring, investigation, and bug fixes.
- Review teammates’ code and write unit and integration tests.
- Apply AI-assisted development workflows when working on user stories.
- —
Fullstack Developer
Red Ocean
Turning business requirements into fullstack applications, from relational data models and business logic to responsive interfaces.
- Requirements analysis with business analysts and frontend implementation from Figma designs.
- Backend and frontend integration, application maintenance, and production issue resolution.
- Unit and integration testing with JUnit, Mockito, and Jest.
02 Selected work / AI developer tooling
AI Development Workflow
for VS Code & Claude CLI.
A plugin I built to coordinate AI-assisted work on development stories. It connects to Jira through an MCP server and uses Confluence through MCP. An orchestrator delegates work to specialized agents following a test-driven development workflow.
Test-driven workflow
The orchestrator divides story work between agents. Tests guide implementation and verification, with reusable skills providing instructions for the workflow.
Engineering considerations
Useful context, meaningful tests, and review remain essential. Splitting work between agents also introduces coordination overhead.
Explore the seven-step workflowSynthetic illustration of the process, not a recording of the plugin running.
Step 1 of 7 · Jira issue
01 / 07 Starting point
Start with a concrete problem.
An issue identifier gives the workflow a defined entry point. In this fictional example, retrying a request must not create a second order.
- Input
- A Jira issue identifier: DEV-142.
- Output
- An issue description and acceptance criteria to investigate.
A shared problem statement keeps each agent working toward the same outcome.
DEV-142 · synthetic issue
Prevent duplicate order creation
Given the same idempotency key
When POST /orders is retried
Then return the original order
And do not create another order02 / 07 Coordination
Give each agent a clear job.
The plugin can be used in VS Code and Claude CLI. This illustrative workflow shows an orchestrator coordinating specialized agents, with reusable skills providing task-specific instructions.
- Input
- The Jira issue, relevant Confluence context via MCP, and repository context.
- Output
- A sequence of scoped tasks for specialized agents.
Explicit handoffs reduce duplicated work and make responsibilities easier to inspect.
workflow · illustrative handoffs
issue: DEV-142
analysis → requirements + context
planning → implementation approach
testing → failing tests
implementation → code changes
verification → check + refine03 / 07 Requirements & context
Understand before changing.
Analysis connects the requested behavior to the existing code and identifies assumptions that need attention. Ambiguous requirements should be surfaced, not silently invented.
- Input
- The issue, acceptance criteria, and relevant source code.
- Output
- A focused interpretation of the problem and open questions.
The right implementation starts with the right problem, especially around edge cases.
analysis.md · example questions
Inspect
Order API and persistence flow
Clarify
Same key, different payload?
What about concurrent requests?
How long is a key retained?04 / 07 Implementation design
Make the approach reviewable.
A plan breaks the change into small steps and makes dependencies visible before implementation. In this example, duplicate handling must account for persistence and concurrency.
- Input
- The analysis, repository conventions, and clarified requirements.
- Output
- An implementation plan with a corresponding test strategy.
A visible plan makes scope and architectural trade-offs easier to challenge early.
plan.md · illustrative scope
01 Define the retry contract
02 Add duplicate-request tests
03 Enforce key uniqueness
04 Return the existing order
05 Verify concurrent retries
Keep the change scoped to DEV-14205 / 07 Test-first development
Describe the behavior in tests.
Testing agents create tests that initially fail. These make the intended change observable and give implementation agents a concrete feedback loop.
- Input
- Acceptance criteria and the implementation plan.
- Output
- Failing tests describing the missing behavior.
Writing the expectation first helps prevent tests from merely repeating an implementation.
OrderServiceTest.java · pseudocode
@Test
void aRetryReturnsTheOriginalOrder() {
var first = createOrder("key-142");
var retry = createOrder("key-142");
assertEquals(first.id(), retry.id());
assertEquals(1, countOrders());
}06 / 07 Focused code changes
Implement against the contract.
Implementation agents work from the plan and failing tests. The change is refined using test feedback, with the existing codebase and conventions as constraints.
- Input
- The plan, failing tests, and relevant source files.
- Output
- A proposed code change that addresses the tested behavior.
A narrow feedback loop keeps the change tied to its original requirements.
implementation · example approach
Validate the request
Look up the idempotency key
Return an existing matching order
Otherwise persist with a unique key
Handle a concurrent insert conflict
Run tests → inspect → refine07 / 07 Feedback & review
Verify, then review the change.
Test results guide another iteration where needed. Passing tests are useful evidence; engineering judgment is still needed to assess coverage, assumptions, and the final diff.
- Input
- The implementation, test results, and original acceptance criteria.
- Output
- A reviewable change and a record of what was checked.
Verification closes the feedback loop without treating generated code as automatically correct.
review.md · illustrative checklist
[ ] Retry behavior matches the issue
[ ] Concurrency is covered
[ ] Existing tests still pass
[ ] Diff stays within the scope
[ ] Assumptions are documented
Failure? Return to implementation.
From code to conversation
Sharing the workflow
behind the tools.
Presenting how MCP, reusable skills, and specialized agents fit together in a practical development workflow.
- MCPConnecting tools and context
- SkillsMaking instructions reusable
- AgentsGiving each step a clear role
03 Engineering expertise
Backend first.
Practical AI tooling.
Experience across implementation, production support, and developer workflows, with Angular as a complementary skill.
Backend & distributed systems
Implementing business logic in Java and Spring Boot, working with REST APIs, relational data, and Kafka integrations in distributed enterprise applications.
Java · Spring Boot · Kafka · PostgreSQL · REST · DDD · CQRS
AI-assisted development & tooling
Using AI in day-to-day development and building a plugin for VS Code and Claude CLI. An orchestrator delegates story work to specialized agents following a test-driven workflow.
VS Code · Claude CLI · GitHub Copilot · MCP · Jira · Confluence
Production support & quality
Monitoring services, investigating production bugs, reviewing code, and writing automated tests. My hands-on AWS experience is limited to adding service configuration values in Systems Manager Parameter Store.
Prometheus · Grafana · JUnit · Mockito · Docker · CI/CD · AWS Parameter Store
Fullstack perspective
Building Angular interfaces and integrating them with backend services. Frontend experience helps me follow a feature across the API boundary, while backend engineering remains my main focus.
Angular · TypeScript · REST · Jest · Figma
04 About & direction
A backend foundation.
A direction in AI engineering.
I have worked on enterprise applications since 2020, including financial services. My responsibilities connect business requirements with implementation, code review, and ongoing production support.
I am developing toward AI engineering through hands-on work on developer tooling and agent workflows. My current focus is using AI during software development and building the tools that coordinate that work.
Education
Postgraduate studies · 2019–2020
Java EE Software Production
Warsaw University of Technology
Master’s degree · 2012–2017
Journalism and Media Studies
University of Warsaw
05 Get in touch
Let’s talk
backend & AI tooling.
I’m interested in senior Java and backend opportunities where I can deepen my work on enterprise systems and grow toward AI engineering.