At ClearSky, we are always exploring how emerging technology can help our engineering team build better software. Recently, I led an internal tech session focused on a major shift happening across our development teams: moving away from basic web-based AI chatbots and letting autonomous AI agents cook directly inside our local coding environments.
The evolution beyond autocomplete
When AI first entered the software scene, most developers used it as a glorified autocomplete tool. You would start typing a function, and the editor would suggest the next few lines. It saved a bit of typing, but the heavy lifting of figuring out where code belonged, running builds, and fixing compilation errors was still entirely manual. Today, we have entered the era of autonomous coding agents. Instead of asking an AI to write a single snippet of code, we give it a high-level goal. The agent reads the repository, writes a step-by-step execution plan, edits multiple files, runs local test suites, reads build errors, and self-corrects in a loop until the job is done.
Plan, implement, and review
To get the best results from AI agents, throwing a prompt at a machine and hoping for the best is not enough. We advocate for a structured approach split into planning, implementation, and review. First, before writing any code, we work with the agent to create a clear plan, pointing it to relevant files and refining the solution together. Second, once the plan is approved, we let the agent execute the work autonomously in the background. Finally, after the code is generated, we bring in a second AI model to review the output against the original plan. Having a fresh set of digital eyes ensures we catch subtle bugs early, preventing an agent from simply checking its own homework. This separation also allows us to use top-tier reasoning models to design the blueprint, while using faster, lower-cost models to do the routine building.
Working in parallel without the drag
One of the biggest pitfalls with standard web tools is context blindness. A chatbot on a website does not know your project structure, your build commands, or your design rules. To solve this, we use lightweight configuration files named "AGENTS.md”. Think of this as an onboarding guide you would hand to a new junior developer on their first day. It tells the AI agent which libraries to avoid, how the architecture should be structured, and what testing rules to follow. This transforms the agent from a generic chatbot into an effective team member that produces code aligned with our standards.
One of the greatest practical hurdles with AI coding is waiting. When an agent is working through a complex task, it might take twenty minutes to complete its build and test loops. Sitting there staring at a terminal screen is a waste of human potential. By using separate, isolated workspaces on our local machines through a git feature called worktrees, our engineers can set an agent off on one task, switch to another clean workspace, and start planning the next feature. It allows us to manage multiple streams of work in parallel without cluttering our primary code branches.
Do software engineers still matter?
With AI doing so much of the heavy lifting, the obvious question arises: do software engineers still matter? The answer is an emphatic yes. The engineer's role has simply shifted up the stack. Instead of spending the majority of our day hand-typing code, wrestling with syntax, and doing manual find-and-replace edits, our focus has moved toward architectural intent, system design, domain knowledge, and rigorous review.
There is a famous 1984 paper by computer scientist Ken Thompson titled Reflections on Trusting Trust, written back when programming compilers were first being adopted. Developers at the time worried about trusting a machine to compile code that humans had written by hand in assembly language. The core lesson then remains true today: quality and security ultimately rely on trusting the human behind the software. When an engineer opens a pull request at ClearSky, they put their name against that code. The AI agent may have helped build it, but the human engineer owns the quality, security, and user outcome.
Building what comes next
By pairing smart AI agents with experienced engineers, we are removing administrative friction from the software development lifecycle. We are not waiting around to see how AI changes software engineering; we are actively implementing the workflows that make our team faster, happier, and more effective for our clients.
References & Further Reading
- Thompson, K. (1984). Reflections on Trusting Trust. Communications of the ACM, 27(8), 761–763.