At El Camino College, one of the most persistent barriers to data-informed decision-making has not been access to data—but the friction required to extract, transform, and operationalize it. Like many institutions running Ellucian Colleague on-prem, we rely heavily on the Ellucian Ethos API layer to modernize access. In theory, Ethos provides a clean, RESTful interface into Colleague. In practice, it introduces a different kind of complexity—one that traditionally requires deep technical expertise, significant trial-and-error, and time that most operational teams simply do not have.
This is the context in which I explored a different approach: using an AI coding agent to “vibe code” directly against the Ethos API—not as a novelty, but as a way to fundamentally compress the distance between intent and execution.
Loïc Audusseau – Chief Technology Officer
The Problem: Ethos Is Powerful but Not Frictionless
Ethos solves a real problem: it abstracts Colleague’s legacy data structures into modern APIs. But several issues quickly emerge when you try to build real applications on top of it:
1. Documentation vs. Reality Gap
Ethos documentation provides endpoint definitions, but it rarely captures:
- Real-world data relationships across modules
- Edge cases in financial or enrollment data
- Required sequencing of API calls
You are often left reverse-engineering behavior through experimentation.
2. Data Model Complexity
Colleague’s underlying data model is not intuitive. Even with Ethos:
- Financial data requires stitching together multiple endpoints
- Enrollment data spans sections, terms, statuses, and student records
- Business logic lives outside the API
This creates a translation problem: understanding what to query is often harder than querying it.
3. Iteration Cost
Traditional development cycles for reporting apps look like this:
- Write code
- Test API call
- Debug response
- Adjust logic
- Repeat
Each iteration is slow, especially when working across multiple endpoints.
The Shift: Using Claude as an Agentic Coding Layer
Instead of treating coding as a manual process, I used Claude as an agentic layer on top of Ethos.
The goal was not just code generation—it was delegating the reasoning process:
- Interpreting API documentation
- Structuring queries
- Handling transformations
- Iterating rapidly based on feedback
In effect, Claude became a Colleague-aware coding agent, capable of:
- Generating working API calls
- Debugging responses
- Refactoring logic in real time
- Building full applications from prompts
This is what I mean by vibe coding: describing the outcome and letting the agent handle the implementation details.
Application 1: Financial Reporting App
The first test was a financial reporting application—something traditionally handled through static reports or complex SQL extracts.
Objective
Create a dynamic reporting interface that:
- Pulls real-time financial data from Colleague via Ethos
- Aggregates by fund, org, and account
- Calculates budget vs. actual vs. encumbrances
- Presents clean, decision-ready outputs
What the Agent Did
Claude:
- Identified relevant Ethos endpoints for financial data
- Structured multi-step API calls
- Built transformation logic to calculate totals and variances
- Generated a working front-end structure
Outcome
What would typically take days (or weeks) of iterative development was reduced to hours of guided prompting and refinement.
More importantly, the app was not static—it was iteratively co-developed in real time.
Application 2: Enrollment Dashboard
The second application focused on enrollment—another area where data fragmentation is common.
Objective
Build a dashboard that:
- Tracks enrollment trends by term
- Breaks down headcount, FTES, and section fill rates
- Allows filtering by program or demographic dimensions
Challenges
Enrollment data is inherently relational:
- Students ↔ Sections ↔ Terms
- Status codes and census rules
- Timing dependencies
- FTES calculation logic
What the Agent Did
Claude:
- Mapped relationships across Ethos endpoints
- Proposed data joins and aggregation strategies
- Generated logic for metrics like fill rate and enrollment trends
- Iterated quickly based on output validation
Outcome
The dashboard emerged through conversation, not traditional development cycles.
Where It Broke (and What That Taught Me)
This process was not seamless. Several challenges surfaced that are important for any institution considering this approach:
1. Context Drift
The agent can lose context across complex workflows.
Lesson: You must anchor the agent with structured prompts and consistent definitions.
2. Hallucinated Endpoints
At times, Claude would generate plausible—but non-existent—API endpoints.
Lesson: Always validate against actual Ethos documentation.
3. Data Misinterpretation
Without domain context, the agent may misinterpret:
- Financial structures
- Enrollment rules
Lesson: Human-in-the-loop is non-negotiable.
4. Over-Generation
The agent tends to over-engineer solutions.
Lesson: Constrain scope aggressively and iterate incrementally.
The Bigger Insight: This Is Not About Coding
What emerged from this process is not just a faster way to build apps—it’s a fundamentally different model:
We are moving from writing code to directing systems.
Instead of:
- “How do I write this query?”
The question becomes:
- “What outcome do I want, and how do I guide the agent to get there?”
This aligns directly with broader trends in AI enablement:
- Institutions that embed AI into operational workflows will move faster
- Those that treat it as an add-on will remain constrained
As highlighted in the broader AI landscape, there is a clear gap between capability and readiness—students and employees alike need structured pathways to build these skills .
Governance and Risk Considerations
This approach also intersects directly with AI governance.
Agentic development touches multiple risk domains:
- Data security (API access, sensitive data)
- Vendor and tool governance
- Algorithmic decision-making
As outlined in the governance framework, application development and AI-enabled systems must be governed through standards around APIs, testing, and oversight .
This reinforces a key point:
Agentic coding is not just a productivity tool—it is a governance concern.
Lessons Learned
- Start with a Clear Use Case
Financial reporting and enrollment were ideal because they are high-value and data-rich.
- Treat the AI as a Junior Engineer (at First)
Guide it, validate it, refine it.
- Prompt Engineering Becomes Architecture
The quality of outputs is directly tied to how you structure inputs.
- Iteration Speed Is the Real Breakthrough
The biggest gain is not code generation—it’s the ability to iterate instantly.
- Human Oversight Remains Critical
Especially in institutional systems with real-world consequences.
Where This Leads
This experiment points to a near-term future where:
- ERP systems like Colleague are no longer bottlenecks
- API layers like Ethos become interfaces for AI agents, not just developers
- Institutional teams can build their own tools without traditional development pipelines
In other words:
The constraint is no longer technical capability—it’s organizational readiness.
And that is precisely where institutions will differentiate.
