# AI Enablement for PeopleSoft > How psLens exports PeopleSoft metadata as Markdown so AI and LLM tools like ChatGPT and Claude can read objects, code, and projects. --- LLMS index: [llms.txt](/llms.txt) --- ## The Problem: PeopleSoft Is a Black Box to AI PeopleSoft hides its source code from the filesystem. Object definitions live in a relational database, not in files. PeopleCode is embedded in the runtime, not on a filesystem where tools can read it. There are no Git repositories, no IDEs with language server support, no standard ways to extract metadata programmatically. This means AI tools like ChatGPT, Claude, and Copilot cannot see your PeopleSoft system. They have general knowledge of PeopleTools concepts, but they have no way to read your specific records, your PeopleCode, your component structure, or your security configuration. You cannot point an LLM at your PeopleSoft environment and ask it to help. Unless you can get the data out first. ## How psLens Exports PeopleSoft for AI psLens exports PeopleSoft object definitions to structured Markdown. Every object type has a one-click export, and the output works in two places: - **Web chat boxes** like ChatGPT and Claude. Paste the Markdown into the conversation and the model reads the full object definition with structure preserved. - **Local AI coding agents** like Claude Code, Cursor, and Aider. Save the export as a file in your project and the agent reads it as context the same way it reads any other source file. Both paths use the same Markdown artifact. Pick whichever your team already works in. ### What You Can Export | Object Type | What the Export Contains | | ------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------- | | **Records** | Field definitions, types, keys, lengths, descriptions, labels, sub-records, SQL definitions, related pages, PeopleCode events, project membership | | **Fields** | Field metadata, translate values, labels, records using the field, PeopleCode references | | **Pages** | Controls and fields, records used, subpages, parent pages, components using the page, PeopleCode events | | **Components** | Pages, menu paths, portal navigation, search records, component interfaces, PeopleCode events, related records | | **Projects** | All project items with counts, PeopleCode source inline, SQL definitions, stylesheets, HTML objects — everything in one document | | **Application Packages** | Package hierarchy, all PeopleCode by class, service operations, references | | **PeopleCode** | Full source code for any PeopleCode program, organized by event or method | Exports include links between related objects so the AI can understand how things connect, not just what a single object looks like in isolation. ### Recursive Reference Resolution For objects containing PeopleCode (such as records, components, application packages, or app engines), enabling **Recursively resolve imports** in the export card instructs psLens to scan the source code for: - Application Class imports (e.g. `import PACKAGE:SubPackage:Class;`) - External function declarations (e.g. `Declare Function Name PeopleCode RECORD.FIELD Event;`) The exporter fetches the source code for each referenced package class and declared function from the database. It appends the resolved code to a `## Resolved PeopleCode References` section at the end of the document. This generates a self-contained snapshot containing both the primary object and all its dependencies, providing the complete context required by AI models without manual retrieval. ## What You Can Do With It ### Code Review and Analysis Export a project or application package and ask an LLM to: - Review PeopleCode for bugs, performance issues, or security concerns - Explain what a complex Application Engine does step by step - Identify unused variables, dead code paths, or redundant logic - Compare coding patterns across different programs - Flag SQL injection risks or other vulnerabilities in PeopleCode PeopleSoft developers have always done code review by reading PeopleCode in App Designer one program at a time. With psLens exports, you can hand an entire project's worth of code to an AI and get a full review in minutes. ### Technical Documentation Export objects and ask an LLM to generate: - Technical specification documents for existing customizations - Data dictionary entries from record and field exports - Component documentation including page flow, security, and data relationships - Migration guides based on project contents - Onboarding documentation for new team members unfamiliar with a module This is especially valuable for undocumented customizations — the ones everyone is afraid to touch because nobody remembers what they do or why they exist. ### Impact Analysis Before making a change, export the relevant objects and ask an LLM: - "What would break if I added a field to this record?" - "Which components and pages use this record?" - "What PeopleCode references this field?" - "If I change this Application Engine step, what downstream effects should I test?" psLens exports include the relationship data that makes this possible: which pages use a record, which components include a page, which projects contain an object, and where PeopleCode references exist. ### Knowledge Transfer PeopleSoft environments accumulate decades of customizations. The people who built them leave. Documentation is incomplete or nonexistent. New team members struggle to understand what exists and why. Export key objects and projects to Markdown and use an LLM to: - Generate summaries of what a customization does and why it might exist - Create Q&A-style knowledge base articles from raw object definitions - Translate technical PeopleSoft structures into plain language for non-technical stakeholders - Build training materials from actual system configuration ### Upgrade and Migration Planning When preparing for a PeopleTools upgrade or a move to PeopleSoft Cloud: - Export projects containing customizations and ask an LLM to assess upgrade risk - Identify PeopleCode patterns that may be deprecated in newer PeopleTools versions - Generate a catalog of all custom objects with descriptions and dependencies - Compare pre- and post-migration exports to verify nothing was lost ### Security Analysis Export permission lists, roles, and security configuration and ask an LLM to: - Identify permission lists with unusually broad access - Find roles that combine conflicting duties (separation of concerns) - Generate audit-ready documentation of who has access to what - Recommend security consolidation opportunities ### Using Exports With Local AI Coding Agents The same Markdown export that works in a chat box works as a context file for a local agent. The usage pattern is: 1. Open the object detail page in psLens and click **Export as Markdown**. The file lands in your downloads folder. 2. Move it into the workspace your agent has access to. For Claude Code or Cursor, that is typically the repo you have open. A `context/peoplesoft/` folder is a useful convention. 3. Reference the file in your prompt. For example, in Claude Code: `Review @context/peoplesoft/PROJECT_HCM_CUST.md and flag any PeopleCode that does unbounded SQL.` The agent reads the file as part of the conversation context. This pattern works for any agent that reads files: Claude Code, Cursor, Aider, Continue, the local-MCP-host model in your IDE. The agent gets the same structured definition a chat user would paste, with the same one-click export workflow on the psLens side. For repeated work against the same set of objects (a customization you maintain, an Application Engine you keep reviewing), keep the exported file in version control alongside the agent's other context. ## Why Markdown Matters LLMs work best with structured text. Markdown gives them: - **Clear hierarchy**: headings, sections, and subsections that establish context - **Tabular data**: field definitions, metadata, and relationships in a format LLMs parse well - **Inline code**: PeopleCode and SQL in fenced code blocks that LLMs recognize as code - **Links and references**: relationships between objects that provide the context an LLM needs to give useful answers Other export formats (CSV, PDF, screenshots) lose structure, context, or both. Markdown preserves everything. ## The PeopleSoft AI Gap Most enterprise platforms have moved toward open formats, APIs, and file-based source code that AI tools can access natively. PeopleSoft has not. Its metadata is locked in database tables, its source code is embedded in the runtime, and its object definitions require App Designer or direct SQL to access. psLens bridges that gap. It reads PeopleSoft metadata through web services and exports it in the format that AI tools consume best. Your team does not need database access, App Designer, or custom SQL to feed PeopleSoft data to an LLM. They just click export. ## Roadmap: psLens as MCP Servers The export-and-paste workflow above puts the developer in the loop. The next step removes that loop: psLens exposes its surfaces as [Model Context Protocol](https://modelcontextprotocol.io) servers so AI tools can query PeopleSoft live. Planned in two pieces: a read MCP (metadata, security, ops, alerts) and an optional action MCP (running reports, triggering comparisons). Five concrete use cases (metadata research, ad-hoc security Q&A, 2am ops triage, recurring report cadences, post-migration drift) are documented on the [Roadmap](/docs/roadmap/) page. Planned. No committed date. ## Get Started
Request a Demo psLens for Developers