AI-Assisted Systems Assignment Engineering Guide
By Arda Akgür (UQ Class of 2019)
GitHub: https://github.com/Arcnaboo/
Introduction
Modern software engineering is changing rapidly.
Large language models are no longer just “code generators.” They can act as implementation assistants, documentation analyzers, protocol explainers, debugging copilots, and architecture companions.
However, complex systems programming assignments cannot simply be solved by prompting:
“Do this PDF.”
That approach usually produces broken architecture, race conditions, protocol violations, memory leaks, and unstable code.
This guide explains the workflow I personally used to successfully complete a highly complex systems programming assessment involving:
- multithreaded networking
- HTTP protocol parsing
- client/server architecture
- concurrent socket handling
- synchronization
- process management
- signal handling
- rolling chat histories
- statistics reporting
The key idea is simple:
Break the assignment into isolated engineering domains and use AI as a guided implementation assistant instead of an autonomous solution generator.
I call this workflow:
The ARC Method
Core Philosophy
The AI should never own the architecture.
The engineer owns:
- decomposition
- system boundaries
- feature isolation
- debugging direction
- integration strategy
- validation
The AI assists implementation.
This distinction is critical.
The ARC Workflow
Step 1 — Upload the Specification
First, upload the official assignment specification PDF into ChatGPT.
Do NOT ask:
“Solve this assignment.”
Instead, isolate one domain of the project.
Example domains:
- communication protocol
- threading architecture
- statistics system
- HTTP request parsing
- reconnect logic
- memory ownership
- signal handling
In my case, I began with:
“Create a detailed communication protocol document between client and server.”
This transforms a giant specification into a focused engineering subsystem.
Step 2 — Generate Focused Technical Documentation
Use ChatGPT to generate:
- protocol documentation
- endpoint maps
- request/response structures
- architecture summaries
- threading models
- state flow explanations
The goal is to create a clean intermediate engineering artifact.
This becomes:
- easier for AI coding agents to consume
- easier for humans to verify
- easier to isolate bugs
Instead of forcing Cursor to understand a 20+ page assignment PDF directly, we provide:
- distilled context
- isolated requirements
- engineering-focused explanations
Step 3 — Convert Documentation Into AI-Consumable Context
Upload the generated documentation into Google Docs.
Export it as Markdown (.md).
Markdown works extremely well because:
- Cursor parses it cleanly
- context becomes structured
- sections are searchable
- headings improve AI retrieval
Example files:
- comm.md
- threading.md
- stats_server.md
Step 4 — Inject the Documentation Into the Project
Place the generated markdown files directly inside the project repository.
Example:
/project
/client.c
/server.c
/comm.md
/threading.md
/stats.md
Now the AI coding assistant has:
- live code access
- structured specifications
- isolated architectural context
This dramatically improves implementation quality.
Step 5 — Use Targeted Prompts
Now use Cursor (or another coding agent) with highly specific prompts.
Example:
“Read comm.md and fix communication handling in client.c.”
Do NOT ask:
“Complete the assignment.”
Instead:
- isolate a subsystem
- focus implementation
- narrow context
- validate incrementally
This avoids:
- hallucinated architectures
- overengineering
- broken abstractions
- giant uncontrolled rewrites
Why This Method Works
1. Reduces Context Explosion
Large assignments overwhelm AI models.
Breaking systems into:
- communication
- threading
- stats
- reconnect logic
- parsing
- synchronization
allows the AI to operate with higher precision.
2. Creates Human-Readable Architecture
The markdown documents become:
- engineering specifications
- debugging references
- onboarding documentation
- architectural maps
This also improves long-term maintainability.
3. Keeps the Human in Control
The engineer remains:
- architect
- reviewer
- debugger
- integrator
The AI becomes:
- accelerator
- assistant
- implementation helper
This creates significantly better outcomes than blind prompting.
Example Engineering Decomposition
For a systems assignment, possible isolated domains include:
Communication Layer
- HTTP request construction
- response parsing
- Content-Length handling
- persistent connections
Concurrency Layer
- mutex ownership
- thread lifecycle
- shared resource synchronization
Process Layer
- fork/exec management
- pipe communication
- child monitoring
Recovery Layer
- reconnect logic
- EOF handling
- retry systems
Signal Layer
- SIGHUP handling
- statistics output
- signal-safe architecture
Memory Layer
- ownership rules
- cleanup flow
- disconnect cleanup
Each can become:
- its own markdown document
- its own AI implementation phase
Important Lessons
AI Is Not a Replacement for Systems Thinking
The AI helped significantly.
But successful implementation still required:
- architectural decisions
- debugging understanding
- protocol validation
- concurrency awareness
- integration control
Without systems understanding, the result would collapse into unstable code.
The Engineer Becomes an Orchestrator
Modern senior engineering increasingly involves:
- decomposition
- orchestration
- verification
- integration
- architecture steering
rather than typing every line manually.
This is not “less engineering.”
It is a different layer of engineering.
Final Thoughts
The future of software engineering will likely belong to engineers who can:
- deeply understand systems
- decompose problems correctly
- orchestrate AI effectively
- validate architecture rigorously
The ARC Method is not about replacing skill.
It is about amplifying engineering capability through structured AI collaboration.
AI is strongest when guided by:
- architecture
- intent
- decomposition
- verification
- systems intuition
That is where real engineering still matters.