Ascelion is an independent software consultancy with over three decades of experience across the full spectrum of software engineering — from microcontrollers and embedded systems to cloud-native Java microservices and distributed architectures.
The core expertise is Java: Spring Boot, JakartaEE, MicroProfile, microservices, event-driven systems, and the full delivery pipeline from design to production. On the systems side, C/C++ and µC-specific assembly cover embedded firmware, native libraries, and performance-critical components.
Infrastructure — Kubernetes, self-hosted services (Jenkins, Gitlab), custom tooling — is part of that ownership, not the centrepiece.
That breadth is not accidental. It comes from consistently taking end-to-end responsibility for what gets built.
AI is now part of how we work. Not because it is fashionable, but because extensive experience in software engineering taught us to recognise good leverage when we see it.
The pattern is familiar: every wave of tooling — IDEs, frameworks, cloud platforms — was supposed to replace engineers. Each wave instead raised the bar for what a lean team can deliver. AI is no different, and we are not worried.
What we are careful about is using AI well. Confidence without verification is how AI causes harm. The principles below are how we keep that in check.
Applied carefully, AI compresses the gap between an idea and working software — without replacing the judgement that makes software good. It cuts through repetitive work, surfaces patterns across large codebases, and lets engineers focus on the decisions that actually require human insight.
Curious how AI actually works? Start with a very basic example →
Boilerplate, documentation, test scaffolding — AI handles the repetitive parts so you stay in flow on the hard problems.
An AI pair that never tires can scan thousands of lines, spot patterns, and surface edge cases a human reviewer might miss after hour eight.
Precise answers about APIs, algorithms, and best practices — right where you are working, without breaking context.
Security review, dependency audits, policy checks — AI makes it practical to run these continuously rather than once before a release.
Traditional automation breaks when the world changes. AI-assisted pipelines can reason about context and recover gracefully.
AI can encode and retrieve the reasoning behind decisions — keeping knowledge accessible long after the moment has passed.
The fear that AI will replace software engineers misunderstands what engineering is. Writing code is the easy part. Understanding a domain, making trade-offs, earning trust, navigating constraints — that is the job. AI cannot do any of it.
What AI can do is remove the parts that should not exist: boilerplate, lookup, mechanical refactoring, repetitive review. When those go away, there is more time for the work that actually matters.
That said, we are not naive about the risks either. AI hallucinates. It is confident when it is wrong. Using it well means building deliberate checks into the workflow — not as bureaucracy, but as craft.
Every consequential AI output passes through a human checkpoint before it affects production. The human is not a rubber stamp — they are the decision-maker. AI informs; the engineer decides.
For fact-finding and exploration, we run dedicated AI agents whose only job is to gather and synthesise information — separate from the agents that write or modify code. Separation of concerns applies to AI too.
If an AI suggestion fails verification three times in a row on the same problem, we stop, step back, and re-approach from first principles. Iteration without reflection compounds errors.
Before acting on any AI-generated fact or code path, we slow down and verify it independently. Named after the sloth: deliberately slow, almost impossible to dislodge once gripped. The most powerful guard we have against hallucination.